\newpage

Utiliser les *cgroup*s
======================

Les *cgroup*s (pour *Control Group*s) permettent de collecter des statistiques
sur des groupes de processus (appelés tâches) et de leur attribuer des
propriétés. Par exemple, il est possible leur imposer des limites d'utilisation
de ressources ou d'altérer leur comportement.


## Premiers tests

Nous allons commencer par faire quelques tests avec le *cgroup* *freezer*, qui
permet d'interrompre l'exécution d'un groupe de processus et de la reprendre.


### Montage du *cgroup*

En fonction de la configuration de votre système, il est possible que les
*cgroup*s ne soient pas montés au démarrage dans `/sys/fs/cgroup/`. Si vous n'avez
pas de dossier `freezer` ou si celui-ci est vide, montez-le en suivant la
procédure suivante :

<div lang="en-US">
```
mkdir /sys/fs/cgroup/freezer/
mount -t cgroup -o freezer none /sys/fs/cgroup/freezer/
```
</div>

Cette dernière commande monte le groupe de processus racine, pour le *cgroup*
*freezer*. Tous les dossiers contenus dans cette racine sont donc des
sous-groupes.


### Création d'un nouveau groupe

La première étape dans l'utilisation d'un *cgroup* est de créer un groupe.

Pour ce faire, il suffit de créer un nouveau dossier dans un groupe existant,
par exemple la racine :

<div lang="en-US">
```
mkdir /sys/fs/cgroup/freezer/virli/
ls /sys/fs/cgroup/freezer/virli/
```
</div>

Nous avons maintenant un nouveau groupe de processus `virli` dans le *cgroup*
*Freezer*. Comme il s'agit d'une hiérarchie, le groupe `virli` hérite des
propriétés de son (ses) père(s).


### Rattachement de processus

Pour le moment, ce nouveau groupe ne contient aucune tâche.

Ouvrons un nouveau terminal (c'est lui que l'on va geler), et récupérons son
PID : `echo $$`.

La liste des processus rattachés à un *cgroup* se trouve dans le fichier `task`
du groupe. Pour ajouter une tâche à ce groupe, cela se passe de cette manière :

<div lang="en-US">
```
echo $PID > /sys/fs/cgroup/freezer/virli/tasks
```
</div>

Il faut ici remplacer `$PID` par le PID du shell que l'on a relevé juste avant.

En validant cette commande, nous avons déplacé le processus dans ce groupe, il
n'est alors plus dans aucun autre groupe (pour ce *cgroup*, il ne bouge pas
dans les autres *cgroup*s).

Malgré l'utilisation de la redirection `>` (et non `>>`), il s'agit belle et
bien d'un ajout au fichier et non d'un écrasement. Il faut garder en tête que
le système de fichier est entièrement simulé et que certains comportements sont
adaptés.


### Consultation de l'état

En affichant le contenu du dossier `virli`, nous pouvions constater que
celui-ci contenait déjà un certain nombre de fichiers. Certain d'entre-eux sont
en lecture seule et permettent de lire des statistiques instantanées sur le
groupe ; tandis que d'autres sont des propriétés que nous pouvons modifier.

Nous pouvons consulter l'état de gel du groupe en affichant le contenu du
fichier\newline `/sys/fs/cgroup/freezer/virli/freezer.state`.

Pour plus d'information sur les différents fichiers présents dans ce *cgroup*,
consultez
[la documentation associée](https://www.kernel.org/doc/Documentation/cgroup-v1/freezer-subsystem.txt).


### Changement d'état

Faisons exécuter à notre interpréteur une commande pour voir effectivement
l'exécution s'arrêter. Si vous manquez d'inspiration, utilisez :

<div lang="en-US">
```
for i in $(seq 9999); do echo -n $i; sleep .1; echo -n " - "; sleep .1; done
```
</div>

Maintenant, nous avons donné l'ordre au noyau de ne plus allouer de temps de
calcul à notre shell et ses fils :

<div lang="en-US">
```
echo FROZEN > /sys/fs/cgroup/freezer/virli/freezer.state
```
</div>

À cet instant, vous devriez voir votre compteur s'arrêter. Pour reprendre
l'exécution :

<div lang="en-US">
```
echo THAWED > /sys/fs/cgroup/freezer/virli/freezer.state
```
</div>


## Exercice : script de monitoring

À nous maintenant de concevoir un script qui va enregistrer vers une base de
données des statistiques issues des *cgroup*s.


### Rappel d'InfluxDB

Commençons par lancer le conteneur Docker d'InfluxDB (pour éviter de
l'installer sur notre machine) :

<div lang="en-US">
```shell
docker container run --name mytsdb -d -p 8086:8086 influxdb
```
</div>

Il nous faut ensuite créer une base de données pour y stocker nos
métriques. Voici comment on s'était débrouillé dans un précédent TP :

<div lang="en-US">
```shell
docker container exec -i mytsdb <<EOF
CREATE DATABASE metrics;
SHOW DATABASES;
EOF
```
</div>

Vérifiez que la base de données `metrics` a bien été créée.


### Monitoring instantané vers la console

Dans un premier temps, commençons par afficher dans la console, la quantité de
mémoire utilisée par le groupe monitoré.

* Arguments de la ligne de commande :
    - premier fils à lancer dans le groupe,
    - intervalle de temps entre deux rafraîchissements ;
* *cgroup* `memory`;
* `memory.usage_in_bytes`.

Vous pouvez utiliser un programme comme `memhog` pour remplir rapidement votre
mémoire.

Si vous n'avez pas le *cgroup* *memory*, il est possible qu'il ne soit pas
activé par défaut par votre système. Si vous êtes dans ce cas, essayez
d'ajouter `cgroup_enable=memory` à la ligne de commande de votre noyau.


### Monitoring vers InfluxDB

Maintenant, envoyons nos données vers la base
<https://docs.influxdata.com/influxdb/v1.3/guides/writing_data/> :

<div lang="en-US">
```
curl -i -XPOST 'http://localhost:8086/write?db=metrics' --data-binary \
    "$my_cgroup_name memory.usage_in_bytes=$(cat .../my_cgroup_name/memory.usage_in_bytes)"
```
</div>

Pour vérifier que les données ont bien été ajoutées, nous pouvons effectuer la
requête suivante dans notre client `influx` :

<div lang="en-US">
```sql
SELECT * from "$my_cgroup_name";
```
</div>


### Monitorer davantage de données

Liste non exhaustive de données à monitorer :

* Nombre d'IOs effectué ;
* nombre d'octets lu/écrit sur les disques ;
* temps de calcul utilisé ;
* trafic réseau généré ;
* ...

Tous les cgroups existants dans le dernier noyau publié ont leur documentation
accessible ici : <https://www.kernel.org/doc/Documentation/cgroup-v1/>


### Permettre à l'utilisateur de monitorer des processus

Maintenant, séparons notre script en deux parties afin qu'un utilisateur normal
(non-root) puisse utiliser la partie monitoring de notre script.

Un premier script doit s'occuper de créer le(s) *cgroup*s et lui attribuer les
bons droits, tandis que le deuxième va effectuer le monitoring, sans privilèges
particuliers.

#### Exemple

<div lang="en-US">
```
42sh$ sudo ./monitor_init my_cgroup_name
42sh$ ./monitor my_cgroup_name memhog 500
```
</div>


## Fixer des limites

Au delà de la simple consultation, les *cgroup*s peuvent servir à limiter la
quantité de ressources mise à disposition à un groupe de processus.

Pour définir une limite, nous allons écrire la valeur dans le fichier
correspondant à une valeur limite, comme par exemple
`memory.max_usage_in_bytes`, qui limite le nombre d'octets que notre groupe de
processus va pouvoir allouer au maximum :

```shell
42sh$ cat /sys/fs/cgroup/memory/virli/memory.max_usage_in_bytes
0
# 0 = Aucune limite
42sh$ echo 4M > /sys/fs/cgroup/memory/virli/memory.max_usage_in_bytes
# Maintenant, la limite est à 4MB, vérifions...
42sh$ cat /sys/fs/cgroup/memory/virli/memory.max_usage_in_bytes
4194304
```

Chaque *cgroup*s défini de nombreux indicateurs et possède de nombreux
limiteurs, n'hésitez pas à consulter la documentation associée à chaque
*cgroup*.


## Pour aller plus loin

Pour tout connaître en détails, [la série d'articles de Neil Brown sur les
Control groups](https://lwn.net/Articles/604609/) est excellente !

Depuis les noyaux 4.5, il est possible d'utiliser la nouvelle version du
pseudo système de fichiers des *CGroup*s. Le principal changement vient du
regroupement au sein d'une seule hiérarchie des différents *CGroup*s que l'on
avait dans la v1. Davantage d'informations sont disponibles :

* [Understanding the new control groups API](https://lwn.net/Articles/679786/)
  ;
* [Kernel Document about Control Group v2](https://www.kernel.org/doc/Documentation/cgroup-v2.txt).
