Navigation

Pour développer et tester Framadate, Picasoft utilise Docker. Ceci permet d’avoir un environnement simple à mettre en place et identique à chaque exécution.

Dans cet article on va considérer que vous travaillez dans un dossier nommé framadate.

Donc pour toute les commandes que nous proposerons vous devrez être dans ce dossier : user@machine:/…/framadate$

Il faut installer docker et docker-compose. Sous Debian / Ubuntu, exécuter sudo apt install docker docker-compose.

Créer le groupe docker:
sudo groupadd docker
et ajouter notre user à ce groupe:
sudo usermod -aG docker $USER

Il faut ensuite fermer la session et la réouvrir. Maintenant, si on exécute docker run hello-world, on devrait avoir un message qui commence par “Hello from Docker!”

Docker fait tourner des images Docker (une image est donc un environnement exécutable). Une image docker est le résultat d’une compilation (build) d’un ensemble de fichiers qui décrit quels programmes doivent s’exécuter et comment. Parmi cet ensemble de fichiers il existe un fichier Dockerfile qui référence tous les autres.

On peut donc, avec Docker, soit utiliser une image déjà compilée, soit construire sa propre image à partir d’un Dockerfile. Dans le cadre de la TX le but étant de développer notre propre version de Framadate, nous devrons reconstruire notre propre image.

Picasoft propose une base de fichiers sources permettant de compiler une image de Framadate à partir de la dernière version stable de Framadate. Nous allons construire cette première image, la tester, et voir ensuite comment construire des images avec notre propre code.

Les sources pour construire l’image Docker de Framadate sont sur le GitLab de l’UTC : Sources Docker. Il s’agit d’un repository Gitlab privé, il faut donc demander les accès à un des membres de Picasoft.

Pour récupérer ces sources :

on clone le dépôt Git des Dockerfiles de Picasoft : git clone https://gitlab.utc.fr/picasoft/dockerfiles.git /tmp/dockerfiles
on récupère les sources qui nous intéressent : mv /tmp/dockerfiles/framadate ./docker

Git va demander des identifiants, il faut rentrer son login et mot de passe UTC (on peut aussi, et même de préférence si l’on sait faire, passer par une authentification SSH).

L’image que nous allons construire est basée sur d’autres images Docker, déjà construites, qui sont sur le registry de Picasoft, il faudra aussi demander les accès à ce registry (login et mot de passe).

On se connecte au registry de Picasoft avec la commande suivante : docker login registry.picasoft.net:5000. On obtient le message Login Succeeded. Cette commande ajoute un fichier ~/.docker/config.json avec les accès au registry, il est donc nécessaire de ne l’exécuter qu’une seule fois.
On peut aussi récupérer un fichier config.json adéquat et le copier sur ~/.docker/config.json

Attention : si vous êtes sur le réseau de l’UTC (par exemple à Roberval, la Mare, la Ruche, …) le port utilisé est bloqué, vous ne pourrez pas utiliser le registry (il faudra passer par un VPN par exemple, ou utiliser une connexion 3G/4G)

On crée le fichier docker-compose.yml avec le contenu suivant :

version: "2"
services:
  framadate-db:
    container_name: framadate-db
    image: mysql:5.7
    command: --sql-mode="ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION"
    volumes:
      - ./volumes/db/data:/var/lib/mysql
    environment:
      - MYSQL_ROOT_PASSWORD=motdepasseroot
      - MYSQL_USER=framadate
      - MYSQL_PASSWORD=framadatedbpassword
      - MYSQL_DATABASE=framadate
    restart: always

  framadate:
    container_name: framadate
    image: framadate
    links:
      - framadate-db:mysql
    ports:
      - 80:80
    environment:
      - DOMAIN=localhost
      - APP_NAME=Framadate
      - ADMIN_MAIL=mon@email.fr
      - MYSQL_USER=framadate
      - MYSQL_PASSWORD=framadatedbpassword
      - MYSQL_DB=framadate
      - MYSQL_HOST=mysql
      - ADMIN_USER=admin
      - ADMIN_PASSWORD=adminpassword
      - DISABLE_SMTP=true
    restart: always

On crée aussi un dossier qui permettra de stocker les données de la base de données de manière persistante avec la commande mkdir -p ./volumes/db/data.

NB : le paramètre -p permet de créer directement l’arborescence de répertoires.

On lance la commande : docker build -t framadate docker

Ceci va builder l’image en local avec le nom framadate (premier paramètre) à partir du fichier Dockerfile présent dans le dossier docker (second paramètre).

On peut vérifier que celle-ci est bien présente sur la machine en affichant la liste des images avec docker images

Une fois que l’image est prête on déploie une instance de Framadate en local avec la commande docker-compose up -d framadate (cette commande prend la configuration présente dans le fichier docker-compose.yml).

On peut voir les logs du conteneur avec la commande docker logs -f framadate. À garder en tête, ça sera très utile par la suite pour le debug.

La première fois que vous lancez Framadate en local, il est nécessaire de faire la migration des bases de données. Pour cela il suffit de se rendre sur http://localhost/admin/migration.php, et de se connecter en utiliser les identifiants d’administration que l’on a configuré dans le fichier docker-compose.yml (admin /adminpassword).

Framadate est ainsi accessible via votre navigateur à l’adresse http://localhost.

Note : le service est configuré pour être lancé sur le port 80, si vous avez déjà quelque chose sur le port 80 sur votre machine, modifiez le fichier docker-compose.yml (ligne ports en remplaçant par exemple par 81:80)

L’instance de test que l’on a déployée est une version stable de Framadate. Ce que l’on souhaite maintenant, c’est de déployer une autre version, par exemple le contenu de mes modifications en cours se trouvant sur un fork du projet.
Dans l’exemple on imagine que mes modifications soient commitées et poussées la branche develop d’un fork à l’adresse https://framagit.org/pichouk/framadate/tree/develop.

Pour commencer il faut récupérer l’URL pour cloner votre fork (il doit être publiquement accessible). Dans l’exemple c’est https://framagit.org/pichouk/framadate.git.
Ensuite on modifie le fichier Dockerfile pour qu’il ne récupère plus le code de Framadate depuis le repository officiel, mais depuis le vôtre. Ainsi la ligne

RUN git clone https://github.com/framasoft/framadate.git /var/www/framadate \

devient

RUN git clone https://framagit.org/pichouk/framadate.git /var/www/framadate \

De plus on veut utiliser le code qui est sur la branche develop donc il faut modifier la variable d’environnement au build FRAMADATEVERSION. Toujours dans le Dockerfile, la ligne <code> ARG FRAMADATEVERSION=1.0.3 </code> devient <code> ARG FRAMADATEVERSION=develop </code> Enfin, on build de nouveau l’image (docker build -t framadate .) et on relance le service (docker-compose up -d framadate). ==== Code en local ==== Il est aussi possible de tester direct une version modifiée du code de Framadate qui se trouve sur votre machine. Dans l’exemple on imagine que le code local de Framadate est dans un dossier /home/kyane/framadate. Pour commencer on va copier les fichiers de l'image Docker (Dockerfile, entrypoint.sh et apache-framadate.conf) dans le dossier contenant votre code de Framadate. <code> cp ./docker/Dockerfile ./docker/entrypoint.sh ./docker/apache-framadate.conf /home/kyane/framadate/ cd /home/kyane/framadate/ </code> Ensuite on modifie le fichier Dockerfile (la copie qui se trouve dans votre dossier de code) pour qu’il ne récupère plus le code de Framadate depuis le repository officiel, mais qu’il copie les fichiers de votre code local dans l’image. Ainsi le bloc suivant <code> # Install Framadate RUN git clone https://github.com/framasoft/framadate.git /var/www/framadate \ && cd /var/www/framadate \ && git checkout $FRAMADATEVERSION \ && php -r “readfile(‘https://getcomposer.org/installer’);” | php \ && touch admin/stdout.log \ && chmod 700 admin/stdout.log \ && mkdir tplc \ && php composer.phar install –no-interaction </code> devient <code> # Copy local files COPY . /var/www/framadate # Install Framadate RUN cd /var/www/framadate \ && php -r “readfile(‘https://getcomposer.org/installer’);” | php \ && touch admin/stdout.log \ && chmod 700 admin/stdout.log \ && mkdir tpl_c \ && php composer.phar install –no-interaction </code> Enfin, on build l’image (docker build -t framadate .) et on relance le service (docker-compose up -d framadate’’).