chroot (Français) - ArchWiki

Jump to content

État de la traduction: Cet article est la version francophone de Chroot. Date de la dernière traduction: 2022-02-06. Vous pouvez aider à synchroniser la traduction s'il y a eu des changements dans la version anglaise.

Related articles

- PRoot
- Linux Containers
- systemd-nspawn

Un chroot est une opération qui modifie le répertoire racine apparent pour le processus en cours d'exécution et ses enfants. Un programme qui est exécuté dans un tel environnement modifié ne peut pas accéder aux fichiers et aux commandes en dehors de l'arborescence des répertoires de l'environnement. Cet environnement modifié est appelé chroot jail (prison «chroot»).

## Raisonnement

Le changement de racine est généralement effectué pour effectuer la maintenance du système sur des systèmes où il n'est plus possible de démarrer et/ou de se connecter. Des exemples courants sont :

- Réinstaller le chargeur d'amorçage.
- Reconstruction de l'image initramfs.
- Mise à jour ou rétrogradation de paquets.
- Réinitialisation d'un mot de passe oublié.
- Construction de paquets dans un chroot propre.

Consultez également Wikipedia:Chroot#Limitations.

## Pré-requis

- Être root.
- Un autre environnement Linux, par exemple un LiveCD ou un support flash USB, ou une autre distribution Linux existante.
- Des environnements avec architectures correspondantes (depuis laquelle on chroot et vers laquelle on chroot). L'architecture de l'environnement actuel peut être trouvé avec : `uname -m` (par exemple, i686 ou x86_64).
- Les modules du noyau chargés qui sont nécessaires dans l'environnement chroot.
- Swap activé si nécessaire :

      # swapon /dev/sdxY

- Une connexion Internet fonctionnelle si nécessaire.

## Utilisation

Note:

- Certains outils systemd tels que hostnamectl, localectl et timedatectl ne peuvent pas être utilisés dans un chroot, car ils nécessitent une connexion dbus active. [1]
- Le système de fichiers qui servira de nouvelle racine (`/`) à votre chroot doit être accessible (c'est-à-dire déchiffré, monté).

Il y a deux options principales pour utiliser chroot, décrites ci-dessous.

### Avec arch-chroot

Le script bash `arch-chroot` fait partie du paquet arch-install-scripts. Avant d'exécuter `/usr/bin/chroot`, le script monte les systèmes de fichiers API comme `/proc` et rend `/etc/resolv.conf` disponible depuis le chroot.

#### Entrer un chroot

Lancez arch-chroot avec le nouveau répertoire racine comme premier argument :

    # arch-chroot /lieu/de/la/nouvelle/racine

Par exemple, dans le guide d'installation ce répertoire serait `/mnt` :

    # arch-chroot /mnt

Pour quitter le chroot, utilisez simplement :

    # exit

#### Exécuter une seule commande et quitter

Pour exécuter une commande depuis le chroot, et sortir à nouveau, ajoutez la commande à la fin de la ligne :

    # arch-chroot /lieu/de/la/nouvelle/racine ma-commande

Par exemple, pour exécuter `mkinitcpio -p linux` pour un chroot situé à `/mnt/arch`, faites :

    # arch-chroot /mnt/arch mkinitcpio -p linux

### Avec chroot

Attention: Lorsque vous utilisez `--rbind`, certains sous-répertoires de `dev/` et `sys/` ne seront pas démontables. Tenter de démonter avec `umount -l` dans cette situation interrompra votre session et nécessitera un redémarrage. Si possible, utilisez `-o bind` à la place.

Dans l'exemple suivant, `/lieu/de/la/nouvelle/racine` est le répertoire où réside la nouvelle racine.

Tout d'abord, montez les systèmes de fichiers temporaires de l'API :

    # cd /lieu/de/la/nouvelle/racine
    # mount -t proc /proc proc/
    # mount -t sysfs /sys sys/
    # mount --rbind /dev dev/

Et optionnellement :

    # mount --rbind /run run/

Si vous utilisez un système UEFI, vous aurez également besoin d'accéder aux variables EFI. Sinon, lors de l'installation de GRUB, vous recevrez un message similaire à : `UEFI variables not supported on this machine` :

    # mount --rbind /sys/firmware/efi/efivars sys/firmware/efi/efivars/

Ensuite, afin d'utiliser une connexion internet dans l'environnement chroot, copiez les détails du DNS :

    # cp /etc/resolv.conf etc/resolv.conf

Enfin, pour changer la racine en `/lieu/de/la/nouvelle/racine` en utilisant un shell bash :

    # chroot /lieu/de/la/nouvelle/racine /bin/bash

Note: Si vous rencontrez l'erreur :

- `chroot : cannot run command '/usr/bin/bash' : Exec format error`, il est probable que les architectures de l'environnement hôte et de l'environnement chroot ne correspondent pas.
- `chroot : '/usr/bin/bash' : permission denied`, remontez avec la permission d'exécuter : `mount -o remount,exec /location/of/new/root`.
  - Si cette vérification n'a pas aidé, alors assurez-vous que les composants de base du nouvel environnement sont intacts (si c'est une racine Arch, essayez `paccheck --root=/location/of/new/root --files --file-properties --md5sum glibc filesystem`, de pacutils).

Après le chrootage, il peut être nécessaire de charger la configuration locale de bash :

    # source /etc/profile
    # source ~/.bashrc

Astuce: Optionnellement, créez une invite unique pour pouvoir différencier votre environnement chroot :

    # export PS1="(chroot) $PS1"

Lorsque vous avez terminé avec le chroot, vous pouvez le quitter via :

    # exit

Puis démontez les systèmes de fichiers temporaires :

    # cd /
    # umount --recursive /lieu/de/la/nouvelle/racine

Note: S'il y a une erreur mentionnant quelque chose comme : `umount : /path : device is busy`, cela signifie généralement que soit : un programme (même un shell) a été laissé en exécution dans le chroot ou qu'un sous-montage existe toujours. Quittez le programme et utilisez `findmnt -R /lieu/de/la/nouvelle/racine` pour trouver et ensuite `umount` les sous-montages. Il peut être délicat de `umount` certaines choses et on peut espérer que `umount --force` fonctionne, en dernier recours utiliser `umount --lazy` qui les libère simplement. Dans tous les cas, pour être sûr, `reboot`ez dès que possible si ces problèmes ne sont pas résolus pour éviter d'éventuels conflits futurs.

## Exécuter des applications graphiques à partir de chroot

Si un serveur X est exécuté sur votre système, vous pouvez lancer des applications graphiques à partir de l'environnement chroot.

Pour permettre à l'environnement chroot de se connecter à un serveur X, ouvrez un terminal virtuel à l'intérieur du serveur X (c'est-à-dire à l'intérieur du bureau de l'utilisateur qui est actuellement connecté), puis exécutez la commande xhost, qui donne la permission à quiconque de se connecter au serveur X de l'utilisateur (consultez également Xhost) :

    $ xhost +local :

Ensuite, pour diriger les applications vers le serveur X à partir du chroot, définissez la variable d'environnement DISPLAY à l'intérieur du chroot pour qu'elle corresponde à la variable DISPLAY de l'utilisateur propriétaire du serveur X. Ainsi, par exemple, exécutez

    $ echo $DISPLAY

en tant qu'utilisateur propriétaire du serveur X pour consulter la valeur de DISPLAY. Si la valeur est ":0" (par exemple), exécutez dans l'environnement chroot :

    # export DISPLAY=:0

## Sans privilèges root

Chroot nécessite des privilèges root, ce qui peut ne pas être souhaitable ou possible pour l'utilisateur dans certaines situations. Il existe cependant plusieurs façons de simuler un comportement de type chroot en utilisant des implémentations alternatives.

### PRoot

PRoot peut être utilisé pour changer le répertoire racine apparent et utiliser `mount --bind` sans les privilèges de root. Ceci est utile pour confiner des applications à un seul répertoire ou pour exécuter des programmes construits pour une architecture de CPU différente, mais il y a des limitations dues au fait que tous les fichiers appartiennent à l'utilisateur du système hôte. PRoot fournit un argument `--root-id` qui peut être utilisé comme une solution de contournement pour certaines de ces limitations d'une manière similaire (bien que plus limitée) à fakeroot.

### Fakechroot

fakechroot est une bibliothèque «shim» (cale) qui intercepte l'appel chroot et simule les résultats. Elle peut être utilisée en conjonction avec fakeroot pour simuler un chroot comme un utilisateur normal.

    $ fakechroot fakeroot chroot ~/my-chroot bash

### Unshare

Unshare, qui fait partie de util-linux, peut être utilisé pour créer un nouvel espace de noms du noyau. Cela fonctionne avec la commande chroot habituelle. Par exemple :

    $ unshare --map-root-user chroot ~/namespace /bin/sh

## Dépannage

### arch-chroot: /location/of/new/root is not a mountpoint. This may have undesirable side effects.

Lors de l'exécution de `arch-chroot /location/of/new/root`, un avertissement est émis :

    ==> WARNING: /location/of/new/root is not a mountpoint. This may have undesirable side effects.

Consultez arch-chroot(8) pour une explication et un exemple d'utilisation de bind mounting pour faire du répertoire chroot un point de montage.

## Voir aussi

- Chroot de base

Categories:

- System recovery (Français)
- Sandboxing (Français)
- Commands (Français)