===== Développement de Framadate avec Docker =====

==== Docker ====

Pour développer et tester Framadate, Picasoft utilise [[https://fr.wikipedia.org/wiki/Docker_(logiciel)|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$''

==== Installer Docker ====

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

==== Configurer Docker ====

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!"

==== Image Framadate ====

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.

==== Sources de l'image Docker de Framadate sur le Gitlab Picasoft ====

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 : [[https://gitlab.utc.fr/picasoft/dockerfiles/tree/master/framadate | 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). 

==== Repository Docker de Picasoft ====

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)


===== Déployer un Framadate de test =====

==== Préparation ====

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

<code>
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
</code>

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.

==== Build de l'image ====

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''



==== Démarrage du service ====

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)

===== Test son code Framadate =====

==== Code sur un repository Git distant ====

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 
<code>
RUN git clone https://github.com/framasoft/framadate.git /var/www/framadate \
</code>
devient
<code>
RUN git clone https://framagit.org/pichouk/framadate.git /var/www/framadate \
</code>

De plus on veut utiliser le code qui est sur la branche ''develop'' donc il faut modifier la variable d'environnement au build ''FRAMADATE_VERSION''. Toujours dans le Dockerfile, la ligne
<code>
ARG FRAMADATE_VERSION=1.0.3
</code>
devient
<code>
ARG FRAMADATE_VERSION=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 [[https://gitlab.utc.fr/picasoft/dockerfiles/tree/master/framadate|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 $FRAMADATE_VERSION \
    && 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>
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'').