lanĉo : un lanceur de tâches utilisant les cgroups

Vincent Bernat

Mise à jour (07.2021)

lanĉo ne fonc­tionne pas sur un sys­tème uti­li­sant les cgroups v2, ce qui est le cas avec les dis­tri­bu­tions mo­dernes. Je ne pré­vois pas de mise à jour. Une bonne al­ter­na­tive est d’uti­li­ser sys­temd-run.

Il y a quelques mois, je cher­chais à lan­cer des tâches per­sis­tantes pour le compte d’un dé­mon tiers dans le but que celles-ci ne soient pas in­ter­rom­pues lorsque le dé­mon est re­dé­marré. Voici le ca­hier des charges :

  • Au­cun pri­vi­lège n’est né­ces­saire pour lan­cer une tâche.
  • Les tâches à lan­cer ne sont pas connues par avance.
  • La sor­tie de chaque tâche est re­di­ri­gée dans un journal.
  • Les tâches sont iden­ti­fiées par un nom fourni.
  • Ce nom per­met en­suite de vé­ri­fier si une tâche tourne tou­jours ou de la tuer.
  • Une tâche ne doit pas être in­ter­rom­pue par un évè­ne­ment ex­terne comme un chan­ge­ment de confi­gu­ra­tion ou une mise à jour lo­gicielle.

Le der­nier point est la rai­son pour la­quelle les tâches ne sont pas exé­cu­tées di­rec­te­ment par le de­man­deur dont le mode d’opé­ra­tion ou la com­plexité peut né­ces­si­ter des re­dé­mar­rages ré­gu­liers. Bien qu’il soit pos­sible de ré­exé­cu­ter un dé­mon tout en gar­dant les pro­ces­sus fils (à l’ins­tar de Ups­tart), il s’agit d’une tâche dif­fi­cile : elle né­ces­site de sé­ria­li­ser l’état in­terne du pro­ces­sus et de le res­tau­rer. Une par­tie de cet état peut être contenu dans des bi­blio­thèques tierces.

Alors que Ups­tart ou sys­temd semblent être de bons can­di­dats, je n’ai pas trouvé de moyen simple de leur faire lan­cer des tâches ar­bi­traires sans pri­vi­lège par­ti­culier1.

Ainsi est né lanĉo2. Il s’agit d’un lan­ceur de tâches très simple : il peut lan­cer des tâches, les ar­rê­ter et vé­ri­fier si elles sont tou­jours pré­sentes. Il uti­lise les cgroups dis­po­nibles dans les noyaux Li­nux ré­cents. Il n’y a au­cun démon.

Vue d’ensemble#

Avant de re­gar­der les rouages de lanĉo, re­gar­dons com­ment l’uti­li­ser. Pour évi­ter les conflits entre dif­fé­rents uti­li­sa­teurs, les tâches sont exé­cu­tées dans le contexte d’un es­pace de noms qui doit être ini­tialisé :

$ sudo lanco testns init -u $(id -un) -g $(id -gn)

Il s’agit de la seule com­mande né­ces­si­tant l’usage des droits root. Les sui­vantes sont lan­cées sans pri­vi­lège par­ti­cu­lier. Lan­çons une pre­mière tâche :

$ lanco testns run first-task openssl speed aes
$ lanco testns check first-task && echo "Still running"
Still running
$ lanco testns ls
testns
 ├ first-task
 │  → 28456 openssl speed aes
 ╯

La sor­tie de cette tâche est placé dans un journal :

$ head -3 /var/log/lanco-testns/task-first-task.log
Doing aes-128 cbc for 3s on 16 size blocks: 8678442 aes-128 cbc's in 2.85s
Doing aes-128 cbc for 3s on 64 size blocks: 2478283 aes-128 cbc's in 2.99s
Doing aes-128 cbc for 3s on 256 size blocks: 628105 aes-128 cbc's in 3.00s

Si la tâche prend trop de temps, il est pos­sible de l’arrêter :

$ lanco testns run first-task openssl speed aes
$ lanco testns stop first-task

Il n’est pas pos­sible d’exé­cu­ter une tâche qui tourne déjà ou d’ar­rê­ter une tâche qui n’existe pas :

$ lanco testns run first-task openssl speed aes
2013-06-09T22:50:34 [WARN/run] task first-task is already running
$ lanco testns stop second-task
2013-06-09T22:50:45 [WARN/stop] task second-task is not running

Grâce à l’uti­li­sa­tion des cgroups, lanĉo est ca­pable de s’y re­trou­ver même si une tâche mul­ti­plie les pro­cessus3 :

$ lanco testns run second-task sh -c \
>  "while true; do (sleep 30 &)& sleep 1; done"
$ lanco testns ls
testns
 ├ first-task
 │  → 28456 openssl speed aes
 ├ second-task
 │  → 29572 sh -c while true; do (sleep 30 &)& sleep 1; done
 │  → 29575 sleep 30
 │  → 29593 sleep 30
 │  → 29596 sleep 30
 │  → 29599 sleep 30
 │  → 29622 sleep 30
 │  → 29644 sleep 1
 │  → 29645 sleep 30
 ╯
$ lanco testns stop second-task
$ lanco testns check second-task || echo "Killed!"
Killed!

Il y a éga­le­ment une com­mande dont la sor­tie est si­mi­laire à top (lanco testns top) :

lanco top
top-like output of running tasks

Utiliser les cgroups#

Les groupes de contrôle (cgroups) per­mettent de par­ti­tion­ner un en­semble de tâches et leur des­cen­dance dans une hié­rar­chie de groupes at­ta­chés à des res­sources.

Hiérarchie#

Com­men­çons par la par­tie hié­rar­chique. Pour créer une nou­velle hié­rar­chie, il suf­fit de mon­ter le pseudo sys­tème de fi­chiers cgroup dans un ré­per­toire vide. Ha­bi­tuel­le­ment, toutes les hié­rar­chies sont re­grou­pées dans /sys/​fs/​cgroups qui est un sys­tème de fi­chiers tmpfs :

# mount -t tmpfs tmpfs /sys/fs/cgroup -o nosuid,nodev,noexec,relatime,mode=755

Nous pou­vons alors créer notre pre­mière hié­rarchie :

# cd /sys/fs/cgroup
# mkdir my-first-hierarchy
# mount -t cgroup cgroup my-first-hierarchy -o name=my-first-hierarchy,none
# ls -1 my-first-hierarchy
cgroup.clone_children
cgroup.event_control
cgroup.procs
notify_on_release
release_agent
tasks

L’op­tion none est obli­ga­toire et nous ver­rons sa si­gni­fi­ca­tion par la suite. Le fi­chier le plus in­té­res­sant est tasks : il contient l’en­semble des tâches as­so­ciées au groupe. Comme nous n’avons pas en­core créé de sous-groupe, tous les pro­ces­sus du sys­tème sont pré­sents dans ce fi­chier. Créons un sous-groupe et dé­pla­çons un pro­ces­sus dans celui-ci :

# mkdir first-child
# cd first-child
# ls -1
cgroup.clone_children
cgroup.event_control
cgroup.procs
notify_on_release
tasks
# echo $$ > tasks
# cat tasks
23184
23311
# cat /proc/$$/cgroup
9:name=my-first-hierarchy:/first-child
8:perf_event:/
7:blkio:/
6:net_cls:/
5:freezer:/
4:devices:/
3:cpuacct,cpu:/
2:cpuset:/
1:name=systemd:/user/bernat/1

Le shell cou­rant et toute sa des­cen­dance a été ajouté au nou­veau groupe. Cela ex­plique pour­quoi nous avons deux tâches : le shell et cat. La der­nière com­mande est in­té­res­sante : pour chaque hié­rar­chie, elle montre à quel groupe ap­par­tient un pro­ces­sus. Pour une hié­rar­chie don­née, un pro­ces­sus fait par­tie d’exac­te­ment un cgroup.

lanĉo uti­lise es­sen­tiel­le­ment cette seule fonc­tion­na­lité : un es­pace de noms est ma­té­ria­lisé par une hié­rar­chie et chaque tâche est en­fer­mée dans un groupe.

Sous-systèmes#

Un sous-sys­tème per­met d’as­si­gner des res­sources par­ti­cu­lières à l’en­semble des tâches conte­nues dans un cgroup. Chaque sous-sys­tème dis­po­nible ne peut être at­ta­ché qu’à une seule hié­rar­chie. Ha­bi­tuel­le­ment, cha­cun est af­fecté à une hié­rar­chie dif­fé­rente afin de ne pas cou­pler les res­sources entre elles4.

Re­gar­dons com­ment fonc­tionne le sous-sys­tème cpuset qui per­met d’as­si­gner les tâches à un sous-en­semble de CPU et de nœuds de mé­moire (sys­tèmes NUMA). Sup­po­sons que notre ma­chine a quatre cœurs et que nous vou­lons af­fec­ter le pre­mier au sys­tème et les trois sui­vants à nginx :

# cd /sys/fs/cgroup
# mkdir cpuset
# mount -t cgroup cgroup cpuset -o cpuset
# echo 0-3 > cpuset/cpuset.cpus
# echo 0 > cpuset/cpuset.mems

# mkdir cpuset/system
# echo 0 > cpuset/system/cpuset.cpus
# echo 0 > cpuset/system/cpuset.mems
# for task in $(cat cpuset/tasks); do
>    echo $task > cpuset/system/tasks
> done

# mkdir cpuset/nginx
# echo 1-3 > cpuset/nginx/cpuset.cpus
# echo 0 > cpuset/nginx/cpuset.mems
# for task in $(pidof nginx); do
>    echo $task > cpuset/nginx/tasks
> done

La pre­mière com­mande mount n’est né­ces­saire que si la hié­rar­chie n’a pas déjà été confi­gu­rée (par sys­temd par exemple). Suite à la confi­gu­ra­tion ci-des­sus, si un pro­ces­sus sys­tème quel­conque de­vient fou, il ne de­vrait pas af­fec­ter les per­for­mances CPU du ser­veur web.

Le noyau contient une do­cu­men­ta­tion plus com­plète. Il y a éga­le­ment quelques ou­tils pour ma­ni­pu­ler les cgroups, comme ceux de libcg, mais ils sont as­sez in­va­sifs et pas tout à fait au point.

Usage dans lanĉo#

Voici com­ment sont ex­ploi­tés les cgroups dans lanĉo :

  • Pour chaque es­pace de noms, une hié­rar­chie sans sous-sys­tème at­ta­ché est créée.
  • En ap­pli­quant les droits ap­pro­priés sur cette hié­rar­chie, un uti­li­sa­teur non pri­vi­lé­gié peut créer de nou­veaux groupes.
  • Chaque tâche est pla­cée dans son propre sous-groupe.
  • Des ac­tions peuvent être exé­cu­tées quand une tâche se ter­mine en uti­li­sant mé­ca­nisme d’agent (re­lease agent)5.
  • Le sous-sys­tème cpuacct est uti­lisé pour suivre l’usage CPU : un groupe est créé à cet ef­fet dans ce sous-système.