Vous êtes sur la page 1sur 11

Cloud Computing

Student Workbook

Master M2
-Expert Réseaux-
-TSD-

Version 1.1
Septembre 2021

Slim MARGHLI
LPI Security Specialist (LPIC-3:Entreprise Security, LPIC2, LPIC-1, Novell CLA 11, Novell DCTS )
LAB n°1: Linux Containers

Description du thème
Propriétés Description
Intitulé long Linux Containers
Formation concernée M2- Expert Réseaux -TSD -
Matière Cloud Computing
Présentation L’objectif de ce Labo est de comprendre la
conteneurisation sous Linux et de faire la
différence avec les solutions de
virtualisations traditionnelles.
Ce Labo comporte 2 activités :
-Activité 1 : Chroot.
-Activité 2 : LXC
-Activité 3 : LXC/LXD
Compétences -Chrooter un shell et des commandes
-Manipuler des conteneurs Linux
Transversalité Virtualisation avancées
Prérequis -Commandes de base d’administration d’un
système Linux.
-Notions de virtualisation.
Outils Un serveur physique ou virtuel avec une
distribution Linux 64 bits
Mots-clés chroot – jail- conteneur linux
Auteur Slim Marghli
Version V1.0
Date de publication Septembre 2021

2
Présentation de l’isolation
L'isolation (aussi appelé cloisonnement) est une technique qui intervient
au sein d’un même système d'exploitation. Elle permet de séparer un
système en plusieurs contextes ou environnements. Chacun d'entre eux est
régi par l'OS hôte, mais les programmes de chaque contexte ne peuvent
communiquer qu'avec les processus et les ressources associées à leur
propre contexte.
Il est ainsi possible de partitionner un serveur en plusieurs dizaines de
contextes, presque sans ralentissement.
L'isolation est utilisée sous Unix depuis longtemps pour protéger les
systèmes. Via des mécanismes comme chroot ou jail il est possible
d'exécuter des applications dans un environnement qui n'est pas celui du
système hôte, mais un « mini système » ne contenant que ce dont
l'application a besoin, et n’ayant que des accès limités aux ressources.
Il est possible également de lancer des programmes dans une autre
distribution que celle du système principal.
Avec l’isolation, l’espace noyau n’est pas différencié, il est unique,
partagé entre les différents contextes. Mais on définit de multiples
espaces utilisateurs cloisonnés. C’est ainsi que l’on peut faire
cohabiter différentes distributions de système d’exploitation, à
condition qu’elles partagent le même noyau.
L’isolation des contextes est une solution légère, tout particulièrement
dans les environnements Linux.
L’unicité du noyau reste bien sûr une petite limitation. D’une part en
termes de robustesse, puisqu’un plantage du noyau – fort heureusement
très rare dans le monde Linux – plante simultanément tous les
environnements. D’autre part dans les utilisations possibles, puisque
typiquement ce mode ne conviendra pas pour valider une nouvelle version
de noyau.
Mais pour les besoins les plus courants de la virtualisation, la
simplicité de mise en œuvre et le faible overhead sont d’excellents
arguments.

3
Activité n°1: Utilisation d’une chroot pour
chrooter un shell
Rappel:
Que fait la commande chroot ?
chroot est un appel système permettant de faire tourner un programme dans
un environnement restreint. La commande chroot prend deux paramètres : le
chemin du nouveau répertoire racine (/), et le chemin du programme à
lancer (relatif au premier argument).
chroot /path/to/new/root /path/to/command
Problème lié à un environnement restreint
Le problème est lié aux librairies partagées qu’il va falloir identifier
et recopier dans la jail. La commande ldd permet d’identifier les
librairies partagées dont le programme a besoin.
Manipulations pratiques
1. Localisez le binaire relatif au bash.
$which bash
/usr/bin/bash
2. Créez un répertoire qui va héberger notre mini-linux.
$ mkdir jail
3. Créez les répertoires de base dans votre jail.
$ mkdir -p jail/usr/bin
$ mkdir -p jail/lib64
4.Copiez bash dans votre répertoire bin situé dans le jail que vous avez
crée
$ cp /usr/bin/bash jail/usr/bin
5.Utilisez la commande ldd pour localiser les bibliothèques nécessaires
au fonctionnement de bash
$ldd /usr/bin/bash
linux-vdso.so.1 => (0x00007ffd4a28e000)
libtinfo.so.5 => /lib64/libtinfo.so.5 (0x00007ffb187e8000)
libdl.so.2 => /lib64/libdl.so.2 (0x00007ffb185e4000)
libc.so.6 => /lib64/libc.so.6 (0x00007ffb18216000)
/lib64/ld-linux-x86-64.so.2 (0x00007ffb18a12000)
6. Copiez ces bibliothèques dans le répertoire convenable de votre jail
$cp /lib64/{ libtinfo.so.5, libdl.so.2, libc.so.6, ld-linux-x86-64.so.2}
jail/lib64
7. Créez l’environnement restreint avec chroot:
# chroot jail /usr/bin/bash
8. Exécutez la commande pwd dans votre jail. Que peut-on déduire?
9. Exécutez la commande ls dans votre jail. Procéder à la résolutions des
problèmes détectés.

4
Activité n°2: Les conteneurs LXC
Rappel:
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 ».
[source : https://fr.wikipedia.org/wiki/LXC]

Manipulations pratiques
1. Installez LXC sur votre machine. Pour pouvoir créer un container LXC
sur CentOS, vous devez installer 3 paquets principaux :lxc,
lxc-templates, libvirt. Le paquet libvirt permet de disposer d’une
interface réseau virtuelle du type virbr0.
#yum install epel-release
#yum install libvirt lxc lxc-templates

5
2. Une fois installés, les modèles de containers disponibles sur CentOS
sont présents dans le dossier /usr/share/lxc/templates. Listez le contenu
de ce dossier.
$ls -l /usr/share/lxc/templates
3. Vérifiez l’environnement LXC en tapant lxc-checkconfig sur la ligne
de commandes.
$lxc-checkconfig
4. Activez et démarrez les services libvirtd et lxc :
#systemctl enable libvirtd
#systemctl enable lxc
#systemctl start libvirtd
#systemctl start lxc
5. Affichez la liste des commandes de LXC.
$lxc- [tabulation]
6. Les containers LXC se créent à l’aide de la commande lx-create . Par
défaut, ils sont stockés dans le dossier /var/lib/lxc/. Le paramètre -t
représente le modèle de système Linux. Créez un container centoslxc en
se basant sur le template centos.
#lxc-create -t centos -n centoslxc
7. Le mot de passe temporaire du container est stocké dans
/var/lib/lxc/centoslxc/tmp_root_pass. Affichez ce mot de passe.
#cat /var/lib/lxc/centoslxc/tmp_root_pass
8. Pour changer le mot de passe sans avoir à se connecter au container
LXC, Il faut “chrooter” son système de fichier. Changez le mot de passe
du container.
#setenforce 0
#chroot /var/lib/lxc/centoslxc/rootfs passwd
9. Démarrez votre container : utilisez la commande lxc-start (Pour
démoniser ce container, autrement dit pour le lancer en service ,
employez le commutateur -d)
#lxc-start -n centoslxc -d
10. Vérifiez que votre container est en exécution.
#lxc-info -n centoslxc
11. Exécutez la commande lxc-info -n centoslxc -i. Que permet le
commutateur -i ?
Le commutateur -i permet de connaître l’adresse ip du container, afin de
s’y connecter en SSH.
12. Le fichier de configuration du container centoslxc se trouve à
l’emplacement /var/lib/lxc/centoslxc/config. Modifiez ce fichier afin que
le conteneur démarre automatiquement.
Il faut ajouter à ce fichier :
lxc.start.auto = 1
Le fichier /var/lib/lxc/centoslxc/config est lui-même hérité du fichier
/etc/lxc/default.conf.
13. Connectez en mode root au container avec la commande lxc-attach et
exécuter dedans les commandes yum install openssh-server, systemctl start
sshd et systemctl enable sshd .

6
lxc-attach -n centoslxc
La commande lxc-attach permet d’exécuter des commandes dans le container
à partir de la machine physique en tant que root.
lxc-attach -n centoslxc yum install openssh-server
lxc-attach -n centoslxc systemctl start sshd
lxc-attach -n centoslxc systemctl enable sshd
14. Connectez vous à votre container et créer un fichier dans son système
de fichier.
lxc-attach -n centoslxc
date>fdate
exit
15. A partir du terminal de votre machine hôte, accédez au système de
fichier de votre container et vérifiez l’existence du fichier crée lors
de la question précédente.
cd /var/lib/lxc/centoslxc/rootfs
ls
fdate
16. Arrêter le container avec la commande ssh
root@adresse_ip_du_container 'poweroff'
#ssh root@adresse_ip_du_container 'poweroff'
il est possible aussi d’utiliser la commande: lxc-stop -n centoslxc
17. Veuillez détruire le container créé précédemment.
lxc-destroy -n centoslxc
rm -fr /var/lib/lxc/centoslxc

7
Activité n°3: Les conteneurs LXC/LXD

Rappel: LXD

Le souci avec LXC, c'est qu'il n'est pas aussi facile à installer et
manipuler que Docker. Suite à ça, les développeurs de Canonical ont
décidé de faire encore plus simple en créant une surcouche appelée LXD.
Il s'agit d'un daemon exposant une API REST qui permet de contrôler LXC.
Et le client de cette API REST est la commande lxc.
Attention, pour éviter toutes confusions, les commandes LXC d'avant LXD
sont de type lxc_create. Le client console communiquant avec LXD est la
commande lxc.

Manipulations pratiques
1. Installez LXD sur votre machine.
$sudo apt-get install lxd lxd-client
2. Ajoutez votre compte utilisateur au groupe lxd pour qu'il gère les
conteneurs LXD sans erreur d'autorisation.
$sudo usermod -aG lxd $USER
$sudo newgrp lxd
3. Configurez l'environnement LXD en utilisant $lxd init

4. Affichez la liste de conteneurs linux


$lxc list
+------+-------+------+------+------+-----------+
| NAME | STATE | IPV4 | IPV6 | TYPE | SNAPSHOTS |
+------+-------+------+------+------+-----------+

8
5. Lancez un conteneur nommé monconteneur basé sur une image alpine
3.11.
$ lxc launch images:alpine/3.11 monconteneur
6. Lancez le conteneur Ubuntu18 basé sur une image ubuntu 18.04.
$lxc launch images :ubuntu/18.04 ubuntu18
7. Affichez la liste de conteneurs linux disponibles.
8. Supprimez les conteneurs en cours d’exécution.
$ lxc stop ubuntu18
$ lxc stop monconteneur
$ lxc delete ubuntu18
$lxc delete monconteneur
***
9. Listez les images présentes localement.
$ lxc image list
10. Copiez l’image distante centos 7 en local tout en lui attribuant
l’alias mycentos.
$lxc image copy images:centos/7 loacl: --alias mycentos
11. Copiez l’image distante alpine 3.11 en local tout en lui attribuant
l’alias myalpine.
12. Listez les images présentes localement.
13. Lancez le conteneur test2 à partir de l’image myalpine.
14. Se connectez dans le conteneur test2 avec un shell et faire un update
$lxc exec test2 -- sh
#apk update
#exit
15. Récupérez le hostname de test2 depuis l’extérieur.
$lxc exec test2 -- hostname
16. Supprimez le conteneur test2
***
17. Lancez le conteneur monnginx à partir de l’image myalpine.
$ lxc launch myalpine monnginx
$lxc list
18. Se connectez dans le conteneur monnginx,faire un update et installer
nginx
$lxc exec monnginx -- apk update
$lxc exec monnginx -- apk add nginx
19. Se connectez dans le conteneur monnginx avec un shell
$lxc exec monnginx -- sh
20. Editez la conf nginx « /etc/nginx/conf.d/default.conf
#vi /etc/nginx/conf.d/default.conf

21. créez le répertoire /var/www/html


#mkdir -p /var/www/html
22. Editez un fichier index.html dans le répertoire déjà crée
#vi /var/www/html/index.html

9
….
23. Lancez le service nginx
#/etc/init.d/nginx start
24. Ajoutez nginx au runlevel par defaut
#rc-update add nginx default
#exit
25. Récupérez l’adresse ip de monnginx
26. Exécutez curl @ip_de_votre_conteneur
***
27. Éditez le fichier index.html sur le conteneur monnginx avec lxc file
edit.
$lxc file edit monnginx/var/www/html/index.html
28. Exécutez curl @ip_de_votre_conteneur
29. Sur votre vm, créez un répertoire files et créez dedans les fichiers
index2.html et le fichier template-index.html.
30. Poussez ces fichiers vers la racine du serveur nginx de votre
conteneur avec lxc file push.
$lxc file push files/* monnginx/var/www/html/
28. Exécutez curl @ip_de_votre_conteneur/index2.html
29. Supprimez le conteneur monnginx

***
30. Lancez un conteneur nommé monconteneur basé sur une image alpine
3.11.
$ lxc launch images:alpine/3.11 monconteneur
31. Affichez plus de détail sur votre conteneur
$ lxc info monconteneur
32. Se connectez dans votre conteneur avec un shell bash et créez
file1.txt
$lxc exec monconteneur -- sh
#vi file.txt
33. Exécutez:
$lxc exec monconteneur -- ls
$lxc exec monconteneur -- cat file.txt
34. Faire un snapshot de votre conteneur nommé init:V1.0
$lxc snapshot monconteneur init:V1.0
35. Exécutez $ lxc info monconteneur et vérifiez l’existence de votre
snapshot.
36. Faire des modifications dans votre conteneur et faire une autre
snapshot
$lxc snapshot monconteneur init:V2.0
$ lxc info monconteneur
37. Restaurez le snapshot init:V1.0
$lxc restore monconteneur init:V1.0
$lxc exec monconteneur -- ls
38. Restaurez le snapshot init:V1.1
$lxc restore monconteneur init:V1.1

10
$lxc exec monconteneur -- ls
***
39. Faire une copie de votre conteneur nommé copycontainer
$ lxc copy monconteneur copycontainer
$lxc list
...
$lxc start copycontainer
$lxc list

39. Construire une image publishimage à partir du conteneur monconteneur.
$lxc publish monconteneur --alias publishimage --force
$lxc image list
40. Lancer un conteneur publishcontainer à partir de publishimage
$lxc launch publishimage publishcontainer
***
49. Listez les pools de stockage
$lxc storage list
50. Créer un pool de stockage nommé lablxc de type dir.
$mkdir lablxc
$lxc storage create lablxc dir source=/home/cloud/lablxc
$lxc storage list
$lxc storage show lablxc
51. Lancez un conteneur lxcstorage à partir de l’image alpine 3.11
attaché au pool lablxc
$lxc launch images:alpine/3.11 lxcstorage -s lablxc
$lxc storage show lablxc
52. Supprimez lablxc
$lxc delete lxcstorage --force
$ lxc storage delete lablxc

11

Vous aimerez peut-être aussi