Docker: Migrer le stockage AUFS vers Overlay2

La galère de la semaine dernière : mettre à jour le kernel Linux d’une machine hébergeant Docker.

Pour faire simple, il fallait passer d’un noyau 3.x à 4.9. Or, en passant en 4.9, le support d’AUFS n’est plus assuré.

Docker utilisant AUFS pour le stockage de ses images, il faut donc le migrer vers Overlay2 (le nouveau filesystem supporté par Docker).

Petite explication pour les Noobs

J’étais un newbie sous Docker avant d’être confronté à cette problématique : il m’a donc fallu pas mal de documentation pour passer au niveau “Dauphin”.
Voici un petit résumé simpliste de Docker : Docker est un environnement permettant d’exécuter sur une même machine des occurrences multiples d’applications telles que MySQL, PHP, Apache etc.
Ces différentes occurrences sont exécutées en parallèle et peuvent communiquer entre elles par le biais de mécanismes de redirection de ports réseau.

De cette manière, on peut héberger sur une même machine, par exemple, un MySQL 4, un MySQL 5, un PHP 5, un PHP 7, un Apache 1.13 et un Apache 2.x.

Ces occurrences d’applications sont appelées “images”. Ces images, afin de ne pas stocker inutilement des quantités astronomiques de données, sont stockées sous la forme de “layers”.
Pour faire simple, un “layer” va être un tronçon d’image – une fois plusieurs tronçons assemblés, cela forme une image complète. C’est une sorte de diff entre 2 images.

Enfin, vous pouvez aussi stocker vos propres applications (codes PHP, HTML etc.) dans une image. De cette manière, au démarrage du système, vous n’avez qu’à lancer les images sont vous avez besoin, telles des machines virtuelles !

Remarque importante : il est possible de stocker les données de vos applications dans les images – tout autant que de les stocker en dehors (recommandé). Si les données de vos applications sont stockées avec l’image, il est nécessaire d’appliquer une procédure plus complexe que celle qui va être données plus bas.

Préparation

Tout d’abord, on va vérifier où sont les données de nos images Docker. En effet, il serait dommage de perdre les bases MySQL pendant l’export…
Pour cela, il suffit d’afficher le contenu du fichier docker-compose.yml de vos applications :

cat docker-compose.yml

version: '3'

  mysql:
    image: mysql:5.7
    container_name: mysqlMyWebSitev3
    environment:
        MYSQL_ROOT_PASSWORD: **********
        MYSQL_DATABASE: MyWebSitev3
        MYSQL_USER: *******
        MYSQL_PASSWORD: **********
    networks:
      - open
      - netisolation
    ports:
      - "6700:3306"
    volumes:
      - "./conf/mysql/my.cnf:/etc/mysql/my.cnf"
      - "/STORAGE/MyWebSitev3/:/var/lib/mysql"
      - "/etc/timezone:/etc/timezone:ro"
      - "/etc/localtime:/etc/localtime:ro"

(...)

Observez les lignes volumes : on voit que l’emplacement des bases (/var/lib/mysql) provient du stockage local (/STORAGE/MyWebSitev3). De même pour la configuration qui vient de ./conf/mysql/my.cnf.
Donc tout va bien !

Sauvegarde des images

La première étape consiste en la sauvegarde des images Docker présentes sur le système. Cela peut être fastidieux de les sauvegarder une par une, du coup on va écrire quelques lignes pour faire le plus long du travail automatiquement:

mkdir /save
docker images> /save/list.txt
IDS=$(docker images | sed '1d' | awk '{print $3}')
for c in $IDS; do docker save -o /save/$c.tar $c; done

On créé un dossier /save, puis on liste les images dans un fichier /save/list.txt.
Ensuite, on stocke dans la variable $IDS les ID des images Docker.
Enfin, on créé une boucle “for” pour sauvegarder chaque image dans /save sous le nom “ID.tar”.

Une fois fait, on va aussi créer un fichier pour automatiser le nommage des images une fois qu’elles seront restaurées :

cat /save/list.txt | sed '1d' | grep -v "" | awk '{ print "docker tag "$3" "$1":"$2 }'>>/save/tag

En lisant le fichier list.txt qui contient les images docker, leurs noms (tags), ID etc., on génère un fichier de la forme “docker tag ID tag:tag” qui nous servira à la restauration.

Passage de Docker en Overlay2

Pour que Docker passe en Overlay2, rien de plus simple !

Créez le fichier de configuration /etc/docker/daemon.json avec la configuration suivante :

 echo '{ "storage-driver" : "overlay2" }' > /etc/docker/daemon.json

Au redémarrage du démon Docker, Overlay2 sera utilisé à la place d’AUFS.

Restauration des images

Une fois le système redémarré, la commande “docker images” ne devrait plus rien faire apparaitre.
On va donc nettoyer l’ancien filesystem :

rm -Rf /var/lib/docker/aufs

Et maintenant, on va restaurer : une fois n’est pas coutume, on va écrire quelques lignes pour que le plus long se fasse seul :

cd /save
IDS=$(ls *.tar)
for c in $IDS; do docker load -i $c; done
bash /save/tag

On se positionne dans /save. On récupère la liste des fichiers de sauvegarde que l’on met dans $IDS.
Puis avec une boucle “for”, on restaure les images une par une.
Une fois terminé, on exécute le fichier “tag” créé plus haut, pour renommer les images.

Vérification

Après un redémarrage, vous constaterez que la commande “docker images” retourne toute la liste de vos images telles que dans votre souvenir, et vos applications peuvent redémarrer comme avant!

En résumé

On reprend le modus operandi :

1. Vérifier que les données sont en dehors des images (cat docker-compose.yml)
2. mkdir /save
3. docker images> /save/list.txt
4. IDS=$(docker images | sed ‘1d’ | awk ‘{print $3}’)
5. for c in $IDS; do docker save -o /save/$c.tar $c; done
6. cat /save/list.txt | sed ‘1d’ | grep -v “” | awk ‘{ print “docker tag “$3” “$1”:”$2 }’>>/save/tag
7. echo ‘{ “storage-driver” : “overlay2” }’ > /etc/docker/daemon.json
8. reboot
9. rm -Rf /var/lib/docker/aufs
10. cd /save
11. IDS=$(ls *.tar)
12. for c in $IDS; do docker load -i $c; done
13. bash /save/tag
14. reboot
15. docker ps

Et voilà !