• 1. Préparation
• 2. Le système de base
• 3. Bascule vers 9.0
• 4. Les jails
• 5. Conclusion

Histoire d'avoir les ports déjà construits, on installe poudriere, la configuration se résume à pointer sur un FTP proche de chez nous. Ensuite on prépare un environnement pour 9.0 :

poudriere jail  -c -v 9.0-RELEASE -a amd64 -j poudre90
poudriere ports -c

On récupère la liste des ports installés, et tant qu'on y est on récupère aussi leur configuration pour que poudriere reconstruise les ports avec les bonnes options.

(pkg_version -o; jexecall pkg_version -o) >portlist
sort portlistuniq
cut -d' ' -f1 portlist
cp -r /srv/jails/*/var/db/ports/* /usr/local/etc/poudriere.d/options
poudriere bulk -f portlist

Pendant que poudriere mouline, on installe FreeBSD 9.0 sur un système de fichiers à part.

zfs create zroot/slash90
zfs set mountpoint=/slash90 zroot/slash90
zfs create zroot/slash90/usr

cd /slash90
fetch http://ftp.fr.freebsd.org/pub/FreeBSD/releases/amd64/amd64/9.0-RELEASE/{base,kernel,src}.txz
tar -xpf base.txz
tar -xpf kernel.txz
tar -xpf src.txz

Pour les fichiers de configuration, on va copier la configuration depuis notre environnement actuel vers l'installation toute fraîche, puis lancer un coup de mergemaster(8) :

cd /slash90/etc
cp -a /etc/ .
chroot /slash90
mergaster -FUvi

On profite également d'être dans un chroot dans /slash90 pour installer les ports qu'on vient de construire.

La configuration réseau a un peu changé. Une configuration avec plusieurs addresses dans chaque famille ressemble à :

              ifconfig_nfe0=
              "inet 203.0.113.13/24"

              defaultrouter=
              "203.0.113.254"

              ifconfig_nfe0_ipv6=
              "inet6 2001:db8:1:8248::1/64 accept_rtadv"

              rtsold_enable=
              "YES" 
              # 
              ou ipv6_defaultrouter="fe80::f00:baa%nfe0"


              ifconfig_nfe0_alias0=
              "inet  198.51.100.43/32"

              ifconfig_nfe0_alias1=
              "inet6 2001:db8:1:8248::25"

              ifconfig_nfe0_alias2=
              "inet6 2001:db8:1:8248::53"

            

ipv6_network_interfaces n'est plus nécessaire.

On copie également /usr/local/etc dans /slash90.

Pour basculer d'un environnement vers l'autre, il suffit ¹ de faire :

zfs set canmount=noauto zroot/slash82
zfs set canmount=noauto zroot/slash82/usr

vi /slash90/boot/loader.conf
# Ajouter : zfs_load="YES"
# et : vfs.root.mountfrom="zfs:zroot/slash90"
zfs unmount zroot/slash90
zfs unmount zroot/slash90/usr
zfs set mountpoint=/ zroot/slash90
zfs set mountpoint=/usr zroot/slash90/usr
zpool set bootfs=zroot/slash90 zroot

Dans mon cas, l'environnement actuel est installé dans zroot/slash82, avec /usr qui est dans zroot/slash82/usr. Si la racine du système est directement à la racine du pool ZFS, il y aura quelques subtilités, si on passe zroot en noauto il faudra penser à modifier les autres points de montage par exemple. De plus, chez moi /var est dans zroot/var, monté automatiquement par ZFS, donc il n'y a pas besoin de le déplacer.

Au premier essai, ma kimsufi n'a pas démarré. Un peu d'investigation via le le mode rescue-pro d'OVH (un simple netboot avec les disques accessibles) ne donne rien. Un zpool import -o altroot=/mnt plus tard, on refait la bascule dans l'autre sens (en utilisant zroot/slash82), et on retrouve une machine qui boote.

Le lendemain, je retente l'opération, cette fois en vKVM (une machine virtuelle qui démarre sur le disque dur du serveur), et là… le démarrage se passe correctement. Je ne sais pas pourquoi au premier essai, les choses se sont bloquées au boot.

Après un peu d'exploration, on voit qu'il y a certaines choses qui ont été « perdues » :

• ce qui est dans /root (un script de sauvegarde, par exemple) ;
• ce qui est dans /usr/local. J'ai pensé aux ports et à leur configuration, mais j'ai laissé de côté le RTM d'OVH, les dossiers de données de poudriere… ;
• /home (qui ne contenait guère que ~fred/.ssh/authorized_keys d'intéressant).

Il suffit de monter zroot/slash82 (qui est actuellement en canmount=noauto) pour avoir accès à ses données et les réinstaller.

On pourrait tout à fait adopter la même procédure : installer dans un système de fichiers à part, y compris les ports, rapatrier les configurations, et pointer ezjail vers la nouvelle installation. La mise à jour en place semble plus simple, et tellement moins risquée que pour la machine hôte…

ezjail-admin update -s 8.2-RELEASE -U

Attention, freebsd-update essaie de mettre à jour le noyau, il faut le relancer à la main une deuxième fois.

Malheureusement, il faut lancer à la main mergemaster pour chacune des jails (et tant qu'on y pense, mettre à jour le gabarit d'ezjail).

Pour les ports, grâce à la préparation faite plus haut, on a déjà des packages binaires à jour pour nos jails, et il suffit de lancer un jexecall portmaster -a pour tout mettre à jour.

Le passage à 9.0 n'a pas été aussi facile qu'attendu. En particulier, je ne sais pas pourquoi le premier démarrage n'a pas réussi du premier coup, et si c'est dû à l'utilisation de ZFS ou pas. De plus, la méthode que j'ai suivie n'était pas idéale —je suppose qu'en ayant de vraies procédures de backup-restore, je n'aurais pas oublié RTM ou les scripts qui traînent dans /root. D'un autre côté, le paramètre bootfs plus jouer un peu avec les points de montage permet de basculer facilement d'une installation à l'autre ; c'était une promesse de ZFS, et cette promesse est tenue. Au premier essai, c'est ce qui m'a permis de revenir sur une configuration fonctionnelle.

Je regrette de ne pas avoir adopté poudriere plus tôt.

• 1. Parfois, il n'y a presque rien à faire…
• 2. …parfois c'est plus compliqué
  • 2.1. Informations fournies par le shell aux fonctions de complétions
  • 2.2. Renvoyer les candidats à la complétion
    • 2.2.1. Exemple typique
    • 2.2.2. Options mutuellement exclusives
    • 2.2.3. _values: plus simple
    • 2.2.4. compadd: pour construire les complétions au fur et à mesure
  • 2.3. Style
• 3. À voir

Il y a quelques cas où on n'a presque rien à faire pour bénéficier de la complétion sur un nouvel outil. Par exemple, si un outil utilise les conventions GNU, zsh peut parser la sortie de --help pour obtenir la liste des options existantes. Il suffit pour cela d'ajouter quelque chose comme :

compdef _gnu_generic foo

dans un fichier lu par zsh ( .zshrc conviendra), et de relancer son shell pour pouvoir compléter les options de foo. On a même le droit à la documentation des options.

Un autre cas où l'on n'a presque rien à faire est lorsqu'on peut réutiliser une complétion existante. Si un outil attend comme argument uniquement des noms d'hôtes, on utilisera :

compdef _hosts foo

Maintenant, en tapant foo , zsh proposera des complétions basées sur les noms d'hôtes, trouvés par `getent hosts` ou qui sont dans l'une des bases ssh_known_hosts entre autres.

Dans l'exemple au-dessus, _hosts est le nom d'une fonction zsh, dont la définition est (sur mon système) dans /usr/local/share/zsh/4.3.11/functions/Completion/Unix.

La documentation de zsh donne un autre exemple assez courant : le cas d'une commande qui accepte tous les fichiers qui ont une certaine extension.

compdef '_files -g "*.h"' foo

Ici, _files est encore une fonction, définie au même endroit que _hosts (et bon courage à celui qui voudra se plonger dans le code de cette fonction…). La documentation de cette fonction est visible dans le manuel de zsh, au nœud «  Completion Functions > Utility Functions  ».

Lorsqu'on a des besoins plus poussés, au hasard pour un outil tel qu'ezjail, on va devoir coder sa propre complétion. Une complétion n'est en soi qu'une fonction zsh qui est appelée par le shell lorsque l'utilisateur appuie sur TAB (ou C-d pour afficher les complétions).

Les fonctions de complétions sont installées par défaut dans /usr/local/share/zsh/site-functions/ (l'emplacement exact peut dépendre de votre OS). Par convention, le fichier dans lequel vous allez écrire votre fonction de complétion a le même nom que la commande concerné, avec un _ ajouté au début.

Lors du développement d'un fichier de complétion, il sera peut-être plus pratique de pouvoir éditer le fichier sans être root. Dans ce cas, il suffit de choisir un dossier local, par exemple ~/zsh. On placera le fichier de complétion dedans, et on l'ajoute au tableau $fpath (bien sûr, à placer avant l'appel à compinit) :

fpath=(~/zsh $fpath)

Notons que zsh refusera de charger des fonctions (donc des définitions de complétion) si le fichier appartient à un utilisateur autre que root ou l'utilisateur courant, ou s'il est modifiable par un autre utilisateur.

Le fichier de complétion commence avec un tag spécial sur la première ligne :

#compdef ezjail-admin

C'est un commentaire, qui indique à zsh que le fichier contient une complétion, et bien sûr quelle commande est concernée.

Ensuite, on définit une fonction de complétion, et on l'appelle :

              _ezjail () {
    
              # 
              code de complétion
}

_ezjail 
              "$@"

            

2.1 Informations fournies par le shell aux fonctions de complétions

2.2 Renvoyer les candidats à la complétion

                  _ezjail_cmd_create () {
    _arguments -s : 
                  \\
        
                  "-i[file-based jail]" 
                  \\
        
                  "-x[jail exists, only update the config]" 
                  \\
        
                  "-a[restore from archive]:archive:_files" 
                  \\
        
                  "-c[image type]:imagetype:(bde eli zfs)" 
                  \\
        
                  "-C[image parameters]:imageparams:" 
                  \\
        
                  "-s[size of the jail]:jailsize:" 
                  \\
        
                  ":jail name:" 
                  \\
        
                  ":comma-separated IP addresses:"
}

                

                  _ezjail_cmd_archive () {
    _arguments -s : 
                  \\
        
                  "-a[archive name]:archive name:" 
                  \\
        
                  "-d[destination directory]:destination dir:_files -/" 
                  \\
        
                  "-f[archive the jail even if it is running]" 
                  \\
        - archiveall 
                  \\
            
                  "-A[archive all jails]" 
                  \\
        - somejails 
                  \\
            
                  "*:jail:_ezjail_stopped_jails"
}

                

                  _ezjail () {
    
                  local cmd
    
                  if (( CURRENT > 2)); 
                  then
        
                  # 
                  déjà un mot complet sur la ligne; sauter à la fonction
        
                  # 
                  spécifique à cette sous-commande.
    
                  else
        
                  # 
                  on complète la sous-commande
        _values :                                                
                  \\
            
                  "archive[create a backup of one or several jails]"   
                  \\
            
                  "config[manage specific jails]"                      
                  \\
            
                  "console[attach your console to a running jail]"     
                  \\
            
                  "create[installs a new jail inside ezjail\\'s scope]" 
                  \\
            
                  "cryptostart[start the encrypted jails]"             
                  \\
            
                  "delete[removes a jail from ezjail\\'s config]"       
                  \\
            
                  "install[create the basejail from binary packages]"  
                  \\
            
                  "list[list all jails]"                               
                  \\
            
                  "restart[restart a running jail]"                    
                  \\
            
                  "restore[create new ezjails from archived versions]" 
                  \\
            
                  "start[start a jail]"                                
                  \\
            
                  "stop[stop a running jail]"                          
                  \\
            
                  "update[create or update the basejail from source]"
    
                  fi
}

                

                  _ezjail_running_jails () {
    _values : 
                  `_ezjail_list_jails running`
}


                  _ezjail_list_jails () {
    
                  local 
                  jailcfgs=
                  "/usr/local/etc/ezjail"
    
                  local 
                  state=$
                  1
    
                  local j
    ( 
                  cd $
                  jailcfgs && 
                  echo * ) | 
                  while 
                  read j; 
                  do
        
                  case $
                  state
                   in
        running) [[ -f /var/run/jail_${
                  j}.id ]] && 
                  echo $
                  j ;;
        stopped) [[ -f /var/run/jail_${
                  j}.id ]] || 
                  echo $
                  j ;;
        *)       
                  echo $
                  j ;;
        
                  esac
    
                  done
}

                

                  _ezjail_running_jails () {
    _ezjail_list_jails running
}


                  _ezjail_list_jails () {
    
                  local 
                  jailcfgs=
                  "/usr/local/etc/ezjail"
    
                  local 
                  state=$
                  1
    
                  local 
                  ret=1
    
                  local j
    
                  for j
                   in $
                  jailcfgs/*(:t) ; 
                  do
        
                  case $
                  state
                   in
        running) [[ -f /var/run/jail_${
                  j}.id ]] && compadd $
                  j && 
                  ret=0 ;;
        stopped) [[ -f /var/run/jail_${
                  j}.id ]] || compadd $
                  j && 
                  ret=0 ;;
        *)       compadd $
                  j && 
                  ret=0 ;;
        
                  esac
    
                  done
    
                  return $
                  ret
}

                

2.3 Style

A User's Guide to the Z-Shell, Peter Stephenson, Chapter 6: Completion, old and new. Il y a en particulier un tutorial bien fait.

The Z Shell Manual, 20. Completion System, et en particulier 20.6 Utility Functions. Vous en avez certainement une version accessible en local avec info zsh (ou C-h i m zsh depuis emacs). Le manuel est assez aride, je ne l'ai utilisé que comme référence.

zsh completion support for ezjail , de votre serviteur.

• 1. Les jails de FreeBSD
• 2. Mise à jour du système de base
  • 2.1. Pour l'hôte
  • 2.2. Pour les jails
  • 2.3. Et pour les ports ?

Quelques petits rappels pour les malheureux Linuxiens qui ne connaîtraient pas les jails de FreeBSD. Les jails de FreeBSD sont parfois comparées à des chroot sur stéroïdes ; maintenant que Linux a des choses telles qu'OpenVZ ou LXC, il faudrait plutôt utiliser cela comme comparaison.

Les jails pour FreeBSD ont été introduites dans FreeBSD 4.0 (mars 2000) par Poul-Henning Kamp (le développeur derrière UFS2 et pas mal de code tournant autour du stockage disque, l'auteur du malloc(3) de FreeBSD, du cache Varnish, et l'inventeur de l'expression bikeshedding ). Une jail est définie par :

• un dossier racine ;
• un nom d'hôte ;
• optionnellement une ou plusieurs adresses IP ;
• une commande, qui est typiquement /etc/rc pour lancer un FreeBSD complet.

Depuis l'intérieur de la jail, il est impossible de sortir du dossier racine, contrairement à un chroot(2). Les processus tournant à l'intérieur de la jail ne peuvent utiliser que les adresses IP attribuées par l'administrateur pour se connecter ou accepter des connexions externes.

Le dossier attribué à une jail peut être tout petit (une dizaine de fichiers, comme le décrit Bapt dans ses NANO Jails), ou contenir un système FreeBSD complet (voire un système CentOS, en utilisant la couche d'émulation de Linux).

Pour des jails contenant un système FreeBSD complet, on voit qu'il peut rapidement y avoir quelques difficultés d'administration :

• une approche naïve conduirait à avoir autant d'installations de FreeBSD que de jails, ce qui est gourmand en espace disque (et en consommation mémoire, les bibliothèques dynamiques ne pouvant pas être partagées) ;
• lorsqu'une mise à jour est publiée, il faut réaliser autant de mises à jour que de jails ;
• même si créer une jail est facile et se fait en environ 6 lignes, cela pourrait être encore plus simple.

ezjail propose une solution à tout cela, et notamment aux deux premiers points en utilisant mount_nullfs(4) (l'équivalent du mount -o bind de Linux) pour fournir à toutes les jails une unique installation de FreeBSD en lecture seule ; cette installation est appelée la basejail. ezjail a un certain nombre d'autres fonctionnalités, que je ne déveloperai pas ici.

2.1 Pour l'hôte

2.2 Pour les jails

# ezjail-admin update -s 8.1-RELEASE -U

2.3 Et pour les ports ?