Le besoin

L’espace occupé sur mon kDrive augmentait régulièrement, alors que je n’y ajoutais que peu de fichiers. En cherchant un peu, j’ai trouvé d’où venait cet écart : les anciennes versions des fichiers. À chaque modification, kDrive garde une copie de l’ancienne version, ce qui est très pratique pour revenir en arrière, mais beaucoup moins quand un fichier modifié tous les jours finit par peser plusieurs fois sa taille (ma base KeePass par exemple, ou alors un dossier rempli de photos sur lequel on vient changer des métadonnées 🥲).

Grâce à l’outil présenté plus bas, j’ai pu libérer 3,2 Go, soit 686 anciennes versions. Au final, mon quota était largement respecté, mais je souhaitais quand même trouver une solution pour éviter de me retrouver un jour avec un kDrive saturé à cause des anciennes versions.

Ma première idée a été de faire cela via l’interface web de kDrive. Problème : celle d’Infomaniak ne permet de supprimer les versions qu’une par une, fichier par fichier. 😩

En revanche, Infomaniak propose une API qui permet de lister les fichiers, leurs versions, et de les supprimer. De quoi se faire un petit outil !

kdvc

kdvc (pour kDrive Version Cleaner) est donc une petite TUI^{note 1}, écrite en Rust avec ratatui. Elle scanne le drive une première fois, garde l’arborescence dans un cache SQLite local, puis affiche :

• des statistiques globales : nombre de fichiers, espace occupé par les anciennes versions
• un explorateur, avec le poids des versions cumulé par dossier
• le top des fichiers dont les versions prennent le plus de place
• une recherche par nom, extension, taille ou nombre de versions
• le journal des suppressions, exportable en CSV

Pour faire le ménage, on sélectionne un fichier ou un dossier, et on choisit une règle : garder les N dernières versions, supprimer celles de plus de X jours, ou tout supprimer sauf la version courante.

Supprimer, oui, mais pas n’importe quoi

Un outil qui supprime des données en masse, ça mérite quelques garde-fous. Voici les deux principaux :

• La version courante n’est jamais supprimée. L’API ne renvoie normalement que les anciennes versions, mais l’outil vérifie que la liste correspond exactement à ce que le scan a vu. Au moindre doute, la plus récente est protégée : au pire, on garde une version de trop.
• Toute suppression passe par un aperçu, qui liste les versions concernées et l’espace libéré, puis par une confirmation explicite de l’utilisateur.

Écrit avec un agent de code

Ce projet est aussi l’occasion d’un test : je l’ai développé avec Claude Code, en deux soirées. Mon rôle a surtout été de fixer les règles, puis de relire, laissant l’agent choisir le langage et ce qui lui semblait le plus juste.

Sans agent, cet outil serait resté une idée, car je n’aurais pas pris le temps d’apprendre Rust pour ça (ou alors, j’aurais attendu d’atteindre mon quota et sorti un petit script Python à la va-vite, non testé, et certainement moins fiable que cet outil).

Cependant, comme je ne connais pas Rust, je suis bien moins expert du code produit que si je l’avais écrit moi-même. Pour un projet perso de cette taille, c’est acceptable, sachant que la maintenance reste minime, vu le peu de fonctionnalités de l’outil.

Installation

Le plus simple est de passer par mise :

mise use -g github:sylvainmetayer/kdrive-version-cleaner

Des binaires pour Linux, macOS et Windows sont aussi disponibles sur la page des releases.

Il faudra ensuite créer un token d’API Infomaniak avec le scope drive (et accounts pour que l’outil trouve vos comptes tout seul), puis l’exporter dans KDRIVE_TOKEN. Le README détaille le reste.

Si vous venez à utiliser ce projet, n’hésitez pas à faire des retours ou à contribuer sur GitHub !

Une fois n’est pas coutume, commençons par nous mettre à la place des organisateurs des événements tech’. Snowcamp, comme beaucoup d’autres salons cette année a eu du mal à trouver des sponsors. Commençons donc par remercier très chaleureusement ceux qui ont pu rester fidèles.

C’est un vrai soucis, qui a mené d’autres conférences à l’annulation. Ces événements sont notre meilleur moyen d’apprendre, d’échanger, de confronter nos points de vues et d’ouvrir nos horizons. Espérons que ce n’est que passager et en attendant, nous tenons à apporter tout notre soutien aux organisateurs qui font un travail, bénévole, et magnifique !

Passons maintenant à nos retours sur quelques conférences que nous avons pu voir avec Anaïs M. et Jérôme Tama.

La journée de jeudi débute par une dissection technique de la faille XZ Utils de Quentin Dunand et Wassim Ahmed-Belkacem. Ils nous expliquent, étape par étape, la mise en oeuvre de la back door. La présentation est vivante, et l’explication pas à pas clarifie très bien l’ingénierie mise en oeuvre.

Vient ensuite le tour de Jérôme Tama de donner son sujet, ou il nous propose de (re)passer notre permis… de refactorer ! Nous découvrons alors les mécaniques d’OpenRewrite pour pouvoir effectuer des modifications de code à grande échelle, simplement et de manière automatisée.

Loic Gudet nous fait ensuite une démonstration en live d’un prototype d’IA générative avec le thème des « Jeux olympiques de Paris 2024 ». Une manière entre autres de présenter concrètement comment sont utilisés les retours des utilisateurs pour améliorer les réponses proposées, quels sont les coûts liés à la maintenance de ces IA ainsi que les outils utilisés pour mesurer son efficacité. Une conférence instructive pour comprendre tout ce qui se cache derrière la mise en œuvre d’une IA générative.

Sur ce même créneau, Paul Vulliemin et Mélissa Pinon nous font un retour sur la façon de gérer les environnements de développement de leur équipes avec une solution Cloud, en mettant l’accent sur l’élasticité des ressources et la rapidité d’accostage pour les développeurs. Après un comparatif des solutions envisagées, ils nous montrent la solution retenue, Coder et sa mise en place avec une démonstration des fonctionnalités de l’outil et des intégrations sur nos IDE.

Suite à ces présentation, il est désormais l’heure pour moi de faire ma présentation, sur SOPS, dans laquelle je présente comment cet outil peut vous aider à stocker vos secrets de manière sécurisées dans vos dépôts Git, et ce même sans accès à un Secret Manager ou Vault externe.

Après le déjeuner, c’est au tour de Léo Gatellier et  🚀 Tim Ghibaudo de nous faire un REX sans filtre sur leur 3 ans passés à maintenir leur cluster Kubernetes, avec ce qui a bien fonctionné et ce qui reste toujours à améliorer. Dans l’objectif de rendre autonome les équipes de développement, ils présentent comment ils ont automatisé à l’aide de script, CLI et/ou API les tâches récurrentes afin de viser moins d’interventions manuelles, tout en garantissant les contraintes des ops niveau sécurité. Léo et Tim insistent également sur le fait que le plus gros changement n’est pas que technique, mais bien organisationnel et nécessite donc un bon accompagnement pour être une réussite.

Sur ce même créneau, Olivier Leplus et Yohan Lasorsa nous font la présentation de plus de 10 fonctionnalités du web (avec une préférence pour la 9 ¾) qui sont parfois disponible depuis plusieurs années, méconnues et qui pourtant peuvent nous faciliter la vie. Que ce soit dans la gestion des Array ou bien pour centrer un div de manière efficace… Cette conférence apporte des solutions à des problèmes de tous les jours.

En fin de journée, c’est au tour de Anaïs M. de monter sur scène, pour un sujet trop peu évoqué, la discrimination positive, durant lequel elle nous fait part de ses propres expériences et de ses ressentis, montrant ainsi que bien que des progrès aient été effectuées, beaucoup restent encore à faire !

Ces 2 jours de conférences ont été l’occasion de découvrir de nouvelles choses mais également d’avoir des échanges de nombreuses personnes, que cela soit lors de la soirée speaker, ou des discussions autour d’un café lors de la journée de conférences. Merci à tous, participants comme speaker, pour ces échanges de qualités !

Nous souhaitons aussi remercier Bruno Lavit pour les magnifiques photos qu’il a pris lors cette édition. Et finalement, un grand merci à Onepoint pour nous permettre de partager nos expériences lors de ces évènements !

Après les retours de nos collègues, nous allons faire les nôtres sur la partie Build & Deploy de l’édition 2024 de Devoxx France.

Et comme chaque année, le moins que l’on puisse dire, c’est qu’il y avait du choix, avec plusieurs dizaines de conférences sur les façons de packager et déployer nos applications ! Sans plus attendre, voici les sujets qui nous ont marqué avec @cfarges et @jtama dans cette catégorie.

GatewayAPI, 10 ans de maturation pour une nouvelle API Kubernetes

Cette année Kévin Davin est venu nous parler de la Gateway API. <3

En effet, avec pas mal de recul, le constat est clair : la ressource Ingress n’est pas suffisante. Elle prend en charge trop de responsabilité, n’est pas suffisamment spécifique, laissant chacune de ses implémentations faire différent choix pour la même solution (manque de portabilité), et ne rend pas non plus suffisamment de service.

La Gateway API est orientée rôle avec plusieurs kinds:

• La GatewayClass:: Pour le provider, celui qui connait le réseau
• La Gateway :: Pour le cluster operator, celui qui connait le cluster 🤷
• Les GRPCRoute / HTTPRoute:: Pour les développeurs, ceux qui connaissent les applications.

Chaque personne ayant ses compétences, ses connaissances, ses responsabilités, et ses kind.

Cette api va suffisamment loin pour empiéter largement sur une partie des services offerts par les service mesh (dont le traffic splitting).

Replay

Multi Kubernetes, Multi Régions, Au-secours !

Aurélien Moreau et Nicolas Lavacry présentent, au travers d’un REX avec pour exemple une entreprise fictive, les besoins de leur nouvelle entreprise : CASDAL. Cette dernière a en effet 2 marchés : un marché américain, et un français. Comment gérer l’hébergement de cette application ?

On découvre alors comment déployer un environnement Kubernetes sur plusieurs régions, et le besoin de créer plusieurs clusters pour assurer une latence faible, Kubernetes n’aimant en effet pas les latences si un continent sépare plusieurs nœuds. Leur démo, parfaitement maîtrisée permet de nous montrer l’envers du décor et des outils/méthodes pour garantir qualité de service, latence faible et l’intégrité de nos données !

45:27Lire la vidéo « Multi Kubernetes, Multi Régions, Au-secours ! », durée 45 min

Notre dépendance à l’Open Source est effrayante. SLSA, SBOM et Sigstore à la rescousse

Cette conférence, très intéressante, nous montre à quel point nous dépendons de logiciels/dépendances tierces dans nos applications, sur lesquelles nous n’avons pas la main. Cela signifie-t-il pour autant qu’il faut les utiliser sans valider leur intégrité, pour éviter qu’un intermédiaire vienne injecter du code malveillant lors d’une étape de packaging de notre application ?

Abdellfetah Sghiouar nous présente alors des outils sur lesquels nous pouvons nous appuyer pour garantir la traçabilité de nos applications, tel que cosign pour signer nos images avant de les déployer dans notre cluster, ou encore SBOM pour lister tous les paquets utilisés dans notre application.

43:21Lire la vidéo « Notre dépendance à l'Open Source est effrayante. SLSA, SBOM et Sigstore à la rescousse », durée 43 min

Au cœur de la ruche eBPF!

J’avais déjà entendu parler plusieurs fois d’eBPF, sans vraiment savoir ce dont il s’agissait. Cette conférence était donc l’opportunité pour moi de creuser un peu le sujet ! Bien que très technique, Mohammed Aboullaite a bien expliqué le fonctionnement d’un module du kernel et l’évolution d’eBPF. Je ne pense pas avoir l’usage dès demain d’écrire mon propre module kernel, mais je comprends mieux toute la “hype” autour de ça et la plus-value d’eBPF afin de pouvoir simplifier la distribution d’un nouveau module, tout en ayant des performances natives et en gardant la même sécurité.

46:42Lire la vidéo « Au cœur de la ruche eBPF! », durée 47 min

Le cauchemar des attaquants : une infrastructure sans secret

Thibault Lengagne nous montre comment s’appuyer sur Vault et Boundary afin de supprimer la plupart des mots de passes
de nos environnements tout en conservant une approche “Secure by design” et avoir une traçabilité complète des différents accès aux composants applicatifs.

Avec une architecture Zero-Credentials, on dispose d’un seul mot de passe par utilisateur qui permettra d’accéder à travers Boundary
à nos applications. L’association de Boundary et Vault permet de créer des identifiants temporaires et de garder une traçabilité complète des accès aussi bien en environnement de développement que jusqu’à la production.

Thibault nous montre une solution d’architecture et les bonnes pratiques associées à ces concepts. A travers plusieurs petites démo, on commence à avoir envie de déployer ça dans nos environnements après avoir vu la taille de l’équipe grandir.

Fini les rotations de mot de passe à n’en plus finir, on a un accès et le reste est géré par les politiques définies dans le code source de notre infrastructure.

45:27Lire la vidéo « Le cauchemar des attaquants : une infrastructure sans secret », durée 45 min

Check-list ultime pour rendre vos app cloud native

Dans cette conférence Katia Himeur revient sur les différents contextes qui peuvent nous amener à déplacer nos applications sur le “cloud”.

Elle nous rappelle que la définition du “cloud” peut être vastement différente suivant nos interlocuteurs. La complexité, la pléthore de solutions disponibles (plus de 2000 outils disponibles chez la CNCF par exemple) et la diversité des fournisseurs doivent être pris en compte lors d’un projet cloud, que ce soit pour une nouvelle application
ou le portage d’un existant.

Entre la méthodologie et le REX, la conférence de Katia est une mine d’informations et d’inspiration sur la manière d’aborder ce type de projet.

Les points présentés se situent autant au niveau de la technique que de l’humain, avec l’onboarding des équipes et la conduite du changement. Les principaux points durs de ces projets sont pris en compte, serait-ce la recette ultime ?

45:25Lire la vidéo « Check-list ultime pour rendre vos app cloud native », durée 45 min

Le mot de la fin

Merci à @onepoint pour nous permettre de participer chaque année à ce moment privilégié !
N’hésitez pas à aller regarder les autres articles publiés par nos collègues sur les autres thèmes !

Retrouvez notre série d’articles sur Devoxx :

1. Intro
2. Frontend
3. Data/IA
4. Backend

Nous sommes (re)venus à DevoxxFR pour cette 11ème édition, et il y avait du choix ! Avec en moyenne 8 conférences/tool-in-action en parallèle, il y en a pour tous les goûts ! Ça tombe bien, ayant tous des préférences différentes, nous avons pu couvrir un bon nombre des conférences sur différents thèmes : front, IA, CI/CD, Kubernetes…

Pour les moments où il y a trop de choix sur un même créneau, il est toujours possible de compter sur la chaîne YouTube de Devoxx. En effet, la quasi-totalité des talks sont déjà disponibles en replay !

Parmi ce que nous avons eu l’occasion de voir, voici notre top 5 !

Top 5

1^er dans nos ❤️ “Alice au pays d’OpenTelemetry”

Il s’agit d’un REX de la mise en place de l’observabilité dans un projet avec plusieurs briques logicielles. Après une présentation des concepts de l’observabilité, d’OpenTelemetry, @jtama nous présente de façon itérative son expérience et les obstacles rencontrés, afin de dompter ce “collecteur magique” et d’unifier nos logs, traces et métriques.

46:08Lire la vidéo « Alice au pays d’OpenTelemetry », durée 46 min

Lien vers les slides
Lien du CFP

Comprendre et utiliser les modèles de langage d’IA

Cette université de 3h présentée par Sébastien Collet permet de découvrir les modèles de Machine Learning et Deep Learning, leur fonctionnements et limites ainsi que les évolutions des dernières années.

Un focus est également fait sur les modèles de langages prédictifs, ce qui permet de comprendre pourquoi les modèles tel que ChatGPT ont les biais qui ont été relevés récemment (hallucinations, toxicité…).

Si vous souhaitez un cours complet, vulgarisé et abordable, avec un historique des modèles d’IA, ce talk est pour vous !

2:49:50Lire la vidéo « Comprendre et utiliser les modèles de langage d'IA », durée 2 h 50 min

Slides
Dépôt Github
Lien du CFP

Une Architecture GitOps from scratch : Gitlab, Ansible, Terraform, Kubernetes et AWS

Avec cette université de 3 heures, Loïc Ortola et Aurélien Moreau de Takima, nous propose une plongée dans la mise en place d’un cluster Kubernetes via de l’Infrastructure as code.

L’utilisation de chaque outil est justifiée par son rôle. Le talk développe petit à petit la mise en place d’une infrastructure complexe, multi-cluster en partant du provisioning de l’infrastructure jusqu’au déploiement continue des applications dans une approche 100% Gitops.

2:46:41Lire la vidéo « Une Architecture GitOps from scratch : Gitlab, Ansible, Terraform, Kubernetes et AWS », durée 2 h 47 min

Lien du dépôt Gitlab
Lien du CFP

Géopolitique de la data

Avec cette keynote de 20 minutes, Benjamin Bayart co-fondateur de la quadrature du net, nous décrit à travers différents exemples et vulgarisations, ce qu’est la Géopolitique de la data et comment la réglementation européenne a évolué sur la protection des données personnelles.

Il clôture son discours en passant le message que tout ingénieur informatique fait de la géopolitique de la data.

17:56Lire la vidéo « Géopolitique de la data », durée 18 min

Lien du CFP

Démystifions les composants internes de Kubernetes

L’objectif de ce talk est de démontrer que Kubernetes n’est pas “un outil automagique” mais qu’il se base sur des briques logicielles individuellement “simple” mais qui assemblées font la robustesse de Kubernetes.

Au travers d’une démonstration live, Denis Germain nous présente les différentes briques composant Kubernetes et leur utilité pour finalement arriver sur une application déployée sur un cluster “fait main” !

Si vous souhaitez savoir ce qui se cache derrière un “kubectl apply -f mon-deploiement.yaml” ou que vous souhaitez comprendre comment les composants “etcd”, “api-server”, “controller-manager”, “scheduler”, “kubelet”, “containerd” ou “CNI” fonctionnent ensemble, ce talk est pour vous !

43:37Lire la vidéo « Démystifions les composants internes de Kubernetes », durée 44 min

Slides
Github contenant la démo
Lien du CFP

SELECT ‘amazing_features’ FROM “postgresql”

Dans ce Tools in action, Kevin Davin nous propose la (re)découverte de features méconnues ou oubliées de postgresql.

Entre les performances, les sucres syntaxiques et les bonnes pratiques, Kevin nous montre la vaste boite à outil dont dispose postgres pour aider le développeur à proposer des applications plus performantes et maintenables.

Il nous présente aussi quelques mauvaises pratiques qui sont pourtant monnaie courante lorsque l’on aborde ce SGBD d’un œil novice.

Que vous utilisiez ou non postgres, ce talk vous montrera ses super pouvoirs et vous invite à l’essayer.

29:06Lire la vidéo « SELECT 'amazing_features' FROM "postgresql" », durée 29 min

Slides
Dépôt Gitlab
Lien du CFP

Pour finir

DevoxxFR, c’est 3 jours de conférences, voyez ça comme un marathon, pas un sprint ! Planifiez votre programme, et prévoyez des temps de pause, pour faire un tour sur les nombreux stands de produits/logiciels que nous utilisons tous les jours (ou que nous avons eu l’occasion de découvrir), qui sont là pour recueillir des retours d’expérience et propositions d’améliorations !

Pour faciliter vos prises de notes, nous avons également développé un petit outil pour générer automatiquement vos templates de notes en fonction de vos favoris. Le dépôt Github

Écrit à 10 mains avec les fabuleux @cfrezier @cfarges @jtama et @florianallainmat !

On en profite pour faire passer un grand merci à onepoint pour l’organisation de ces 3 jours au top !

Merci ! 😊

50:10Lire la vidéo « Terraform, REX d'un développeur », durée 50 min

Je suis content de moi, qui préfère d’habitude être derrière la caméra. Le fait d’avoir été encouragé à réaliser ce retour d’expérience m’a permis de me dépasser et finalement, la chose à retenir est que 45min, c’est à la fois long et court :)

Pour activer ou désactiver ce comportement, rendez-vous sur les paramètres de votre compte Google

Désormais, j’utilise l’application PhoneTrack sur mon instance Nextcloud. Je souhaitais néanmoins récupérer mes données de 2011 à 2018 (représentant quelques milliers de km) sur ma nouvelle instance.

Cet article présente les différentes étapes pour réaliser cet import.

Récupérer les données de Google

Il faut tout d’abord récupérer l’historique des positions de Google. Pour cela, rendez-vous sur Google Takeout, puis décochez tout, sélectionnez uniquement Historique des positions, et précisez le format des données en JSON (Formats multiples puis JSON). L’export peut être long selon le nombre de données présentes.

À titre indicatif, il m’a fallu environ 20 min pour avoir l’export à disposition

Préparer les données

Une fois l’archive ZIP récupérée et extraite, vous trouverez un fichier Historique des positions.json dans le dossier Historique des positions. C’est ce fichier que nous allons importer dans PhoneTrack :)

Pour ma part, le fichier contient un peu plus d’un million et demi d’enregistrements, pour un poids de ~470 Mo.

~/wip
$ mv Historique\ des\ positions.json google.json

~/wip
$ jq '.locations| length' < google.json
1690273

~/wip took 14s
$ ls -ailh google.json
2498577 -rw-rw-r--. 1 user user 470M 17 mai   13:35 google.json

Il existe sûrement une meilleure façon de faire, mais lors de mes tests, un import direct du fichier dans PhoneTrack plantait, le fichier étant trop volumineux. Il a donc fallu que je découpe le fichier. Pour cela, j’ai fait un rapide script, qui n’est pas parfait mais qui fait le job :)

const fs = require('fs');

const data = JSON.parse(fs.readFileSync('./google.json',
        { encoding: 'utf8', flag: 'r' }));

const locations = data.locations;
let iterations = locations.length;

let dataFile = [];

const fileName = 'google.';
let fileSuffix = 0;

console.log(`${locations.length} locations`);
for (location of locations) {
        if (dataFile.length % 100000 === 0 && dataFile.length > 0) {
                const filename = `google.${fileSuffix}.json`;
                fs.writeFileSync(filename, JSON.stringify({ locations: dataFile }));
                console.log(`Need to write file ${fileSuffix}`);
                fileSuffix++;
                dataFile = [];
        }
        dataFile.push(location);
}

const filename = `google.999.json`;
fs.writeFileSync(filename, JSON.stringify({ locations: dataFile }));
console.log(`Wrote last data file with ${dataFile.length} locations`);

Pour l’usage, cela se passe comme ça : le script va lire un fichier (google.json) et le séparer en fichiers de 100 000 éléments chacun.

~/wip via ⬢ v14.15.0
$ node split.js
1690273 locations
Need to write file 0
Need to write file 1
Need to write file 2
Need to write file 3
Need to write file 4
Need to write file 5
Need to write file 6
Need to write file 7
Need to write file 8
Need to write file 9
Need to write file 10
Need to write file 11
Need to write file 12
Need to write file 13
Need to write file 14
Need to write file 15
Wrote last data file with 90273 locations
$ bc <<< 16*100000+90273
1690273

On retrouve bien nos données séparées, plus qu’à les importer !

Import dans PhoneTrack

Pour cette partie, il vous faudra un accès à votre instance Nextcloud avec l’application PhoneTrack installée, ainsi qu’un accès à sa base de données (client MySQL / MariaDB).

Tout d’abord, voici comment sont organisées les données de PhoneTrack dans la base de données :

MariaDB [nextcloud]> SHOW TABLES WHERE Tables_in_nextcloud LIKE '%phonetrack%';
+-----------------------+
| Tables_in_nextcloud      |
+--------------------------+
| oc_phonetrack_devices    |
| oc_phonetrack_filtersb   |
| oc_phonetrack_geofences  |
| oc_phonetrack_points     |
| oc_phonetrack_proxims    |
| oc_phonetrack_pubshares  |
| oc_phonetrack_sessions   |
| oc_phonetrack_shares     |
| oc_phonetrack_tileserver |
+--------------------------+

Je ne vais pas rentrer dans les détails, mais voici la compréhension que j’ai de comment sont structurées les données dans PhoneTrack :

Un device est un appareil qui envoie des points de localisation (points). Chaque device appartient à une session, et une session peut contenir plusieurs device. Vous trouverez des détails ici si cela vous intéresse : Wiki PhoneTrack - Gitlab

Problème : PhoneTrack ne permet pas de fusionner deux devices depuis l’interface (une issue le demandait d’ailleurs). Or, chaque fichier s’importe comme une nouvelle session, avec son propre device. Le plan est donc le suivant :

1. importer chaque fichier depuis l’interface de PhoneTrack (une session par fichier) ;
2. créer un device dédié, google_location, qui accueillera tout l’historique ;
3. déplacer en base les points de chaque device importé vers ce device ;
4. supprimer les sessions de l’import, devenues vides.

Une fois les imports terminés, voici les devices présents (myPhone et myPhone2 sont mes téléphones, les autres viennent de l’import) :

MariaDB [nextcloud]> SELECT * FROM oc_phonetrack_devices;
+----+------------------+-------+----------------------------------+---------+-------+----------------------------------+
| id | name             | alias | sessionid                        | color   | shape | nametoken                        |
+----+------------------+-------+----------------------------------+---------+-------+----------------------------------+
|  5 | myPhone          | NULL  | redacted_for_privacy             | #3ea8fa | NULL  | NULL                             |
|  8 | myPhone2         | NULL  | redacted_for_privacy             | #ff0001 | NULL  | NULL                             |
|  9 | google1          | NULL  | redacted_for_privacy             | NULL    | NULL  | NULL                             |
| 10 | google10         | NULL  | redacted_for_privacy             | NULL    | NULL  | NULL                             |
| 11 | google11         | NULL  | redacted_for_privacy             | NULL    | NULL  | NULL                             |
| 12 | google12         | NULL  | redacted_for_privacy             | NULL    | NULL  | NULL                             |
| 13 | google13         | NULL  | redacted_for_privacy             | NULL    | NULL  | NULL                             |
| 14 | google14         | NULL  | redacted_for_privacy             | NULL    | NULL  | NULL                             |
| 15 | google15         | NULL  | redacted_for_privacy             | NULL    | NULL  | NULL                             |
| 16 | google16         | NULL  | redacted_for_privacy             | NULL    | NULL  | NULL                             |
| 17 | g2               | NULL  | redacted_for_privacy             | NULL    | NULL  | NULL                             |
| 18 | g3               | NULL  | redacted_for_privacy             | NULL    | NULL  | NULL                             |
| 19 | g4               | NULL  | redacted_for_privacy             | NULL    | NULL  | NULL                             |
| 20 | g5               | NULL  | redacted_for_privacy             | NULL    | NULL  | NULL                             |
| 21 | g6               | NULL  | redacted_for_privacy             | NULL    | NULL  | NULL                             |
| 22 | g7               | NULL  | redacted_for_privacy             | NULL    | NULL  | NULL                             |
| 23 | g8               | NULL  | redacted_for_privacy             | NULL    | NULL  | NULL                             |
| 24 | g9               | NULL  | redacted_for_privacy             | NULL    | NULL  | NULL                             |
| 25 | glast            | NULL  | redacted_for_privacy             | NULL    | NULL  | NULL                             |
| 26 | google_location  | NULL  | redacted_for_privacy             | NULL    | NULL  | redacted_for_privacy             |
+----+------------------+-------+----------------------------------+---------+-------+----------------------------------+
20 rows in set (0.001 sec)

MariaDB [nextcloud]> SELECT COUNT(*) FROM oc_phonetrack_points WHERE deviceid NOT IN(5,8);
+----------+
| COUNT(*) |
+----------+
|  1690271 |
+----------+
1 row in set (1.154 sec)

À quelques points près, on retrouve bien tous nos points importés en base. 🎉

Reste maintenant à les regrouper dans un seul device. Voici le nombre de points par device :

MariaDB [nextcloud]> SELECT name, d.id as deviceid, COUNT(p.id) as points FROM oc_phonetrack_points p RIGHT JOIN oc_phonetrack_devices d ON p.deviceid = d.id GROUP BY deviceid, name;
+------------------+----------+----------+
| name             | deviceid | points   |
+------------------+----------+----------+
| google1          |        9 |        1 |
| myPhone          |        5 |     3162 |
| myPhone2         |        8 |   218854 |
| google10         |       10 |   100000 |
| google11         |       11 |   100000 |
| google12         |       12 |   100000 |
| google13         |       13 |   100000 |
| google14         |       14 |   100000 |
| google15         |       15 |   100000 |
| google16         |       16 |   100000 |
| g2               |       17 |   100000 |
| g3               |       18 |    99998 |
| g4               |       19 |   100000 |
| g5               |       20 |   100000 |
| g6               |       21 |   100000 |
| g7               |       22 |   100000 |
| g8               |       23 |   100000 |
| g9               |       24 |   100000 |
| glast            |       25 |    90273 |
| google_location  |       26 |   100000 |
+------------------+----------+----------+
20 rows in set, 1 warning (1.552 sec)

Pour chaque device de l’import, on rattache ses points au device google_location (ici, l’id 26). Un point appartient à un device, et un device à une session : en changeant le deviceid des points, ils rejoignent donc aussi la session de google_location.

MariaDB [nextcloud]> UPDATE oc_phonetrack_points SET deviceid=26 WHERE deviceid = 10;
Query OK, 100000 rows affected (21.417 sec)
Rows matched: 100000  Changed: 100000  Warnings: 0

Une vingtaine de secondes par device, à répéter pour chacun d’eux. Une fois tous les devices traités :

MariaDB [nextcloud]> SELECT name, d.id as deviceid, COUNT(p.id) as points FROM oc_phonetrack_points p RIGHT JOIN oc_phonetrack_devices d ON p.deviceid = d.id GROUP BY deviceid, name;
+------------------+----------+---------+
| name             | deviceid | points  |
+------------------+----------+---------+
| g2               |       17 |       0 |
| g3               |       18 |       0 |
| g4               |       19 |       0 |
| g5               |       20 |       0 |
| g6               |       21 |       0 |
| g7               |       22 |       0 |
| g8               |       23 |       0 |
| g9               |       24 |       0 |
| glast            |       25 |       0 |
| google10         |       10 |       0 |
| google11         |       11 |       0 |
| google12         |       12 |       0 |
| google13         |       13 |       0 |
| google14         |       14 |       0 |
| google15         |       15 |       0 |
| google16         |       16 |       0 |
| myPhone          |        5 |    3162 |
| myPhone2         |        8 |  218854 |
| google_location  |       26 | 1690271 |
+------------------+----------+---------+
19 rows in set, 1 warning (1.820 sec)

Tous les points sont désormais rattachés à google_location. Il ne reste plus qu’à supprimer les sessions de l’import, désormais vides, depuis l’interface de PhoneTrack (en prenant soin de garder celle qui contient google_location !), et à profiter de quelques années d’historique sur sa propre instance :)

Néanmoins, je disposais quand même du dossier /var/lib/mysql qui semblait intact. J’ai donc fait un tar.gz du dossier avant de le récupérer en local pour voir ce que je pouvais en faire.

# on créé le tar.gz sur le serveur
$ sudo tar -zcvf ~/mysql.tar.gz /var/lib/mysql
# on le récupère en local
$ scp pi:~mysql.tar.gz .

Une fois cela fait, j’ai utilisé Docker et l’image mariadb (dans la version 10.3, qui était celle utilisée sur mon serveur pour éviter toute incompatibilité) pour pouvoir lancer une instance locale de mariadb, avec les données récupérées précédemment.

# Extraction du tar.gz
$ tar -xzvf mysql.tar.gz
$ cd var/lib
# J'aurais besoin de ce dossier pour récupérer mes dump SQL plus tard
$ mkdir backup

$ docker run --name restore_mariadb -v $(pwd)/data:/var/lib/mysql -v $(pwd):/backup -e MYSQL_ROOT_PASSWORD=root -d mariadb:10.3

La variable d’environnement est nécessaire sinon l’image ne démarrera pas, mais il faut bien garder en tête qu’il faudra indiquer le mot de passe de votre instance MySQL telle qu’elle était sur votre serveur.

Une fois cela fait, il suffit de lancer la commande suivante pour se connecter au conteneur :

$ docker exec -it restore_mariadb bash
root@e11929a58f8b:/# mysql -u root -p
Enter password:
Welcome to the MariaDB monitor.  Commands end with ; or \g.
Your MariaDB connection id is 8
Server version: 10.3.23-MariaDB-1:10.3.23+maria~focal mariadb.org binary distribution

Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

MariaDB [(none)]>

Et enfin, on peut faire des mysqldump et stocker les résultats dans le dossier /backup que l’on a également monté pour pouvoir restaurer les données une fois la base de données de nouveau opérationnelle.

mysqldump -u root -p mabase > /backup/mysql.sql

En espérant que cela puisse être utile à d’autres !

Et si jamais vous n’en avez pas de récentes, allez faire une sauvegarde de vos données dès maintenant :)

L’idée

Trop de spam ? Marre de donner son adresse email à chaque service ? Les alias mail sont là à la rescousse !

Suite à une idée d’Adrien Chinour, j’ai décidé de créer à mon tour un petit gestionnaire d’alias pour mes adresses emails. L’objectif est de pouvoir générer rapidement des alias afin de ne pas donner sa véritable adresse email lors d’inscription sur des sites divers. Ainsi, si l’on constate que le site envoie un peu trop de mail à notre goût, que l’on n’utilise plus le service, ou que réussir à se désinscrire relève du parcours du combattant, on supprime l’alias, et plus de mails indésirables !

Ayant mes domaines gérés par Gandi, j’ai regardé comment interagir avec mes adresses emails pour créer des alias depuis leur API.

Au niveau des technologies utilisées, j’ai utilisé Angular et les fonctions serverless de Netlify (en NodeJS) afin de gérer les appels à l’API Gandi.

Le principe est très simple : on s’authentifie avec un mot de passe, prédéfini dans les variables d’environnement des fonctions serverless de Netlify, on obtient un JWT Token signé avec un secret connu seulement par les fonctions serverless, et on peut ensuite considérer que l’on est authentifié. N’ayant pas besoin de gérer plusieurs utilisateurs, cela convient à mon cas d’utilisation.

Une fois authentifié, les fonctions serverless se chargent de récupérer la liste des domaines, ainsi que la liste des boites mails associées à ces domaines et on arrive ensuite sur l’écran suivant, qui nous permet de gérer les alias de chaque boite mail.

La suite

Dans le cas où d’éventuels clients de Gandi souhaiteraient utiliser ce projet, j’ai tenté d’intégrer l’Oauth2, afin de permettre de s’authentifier via Gandi. Cela m’a également permis de comprendre mieux le fonctionnement de l’Oauth2.

J’ai donc demandé la création d’une application, obtenant ainsi un applicationId et un applicationSecret me permettant de mettre en place l’authentification. Afin de tester cela en local, j’ai utilisé un mock oauth2 réalisé par le groupe AXA

Malheureusement, l’API v5 de Gandi est encore en beta et le fournisseur d’authentification ne permet pas encore d’interagir avec les domaines et boites mails. 😢

En attendant que cela soit disponible, j’ai laissé mon travail disponible sur une branche dédiée.

J’ai également ajouté un bouton de déploiement Netlify en un clic pour ceux souhaitant se servir de ce petit projet. Il faudra néanmoins générer sa propre clé d’API depuis les paramètres de son compte Gandi et renseigner quelques variables d’environnement, décrites ci-dessous.

Tableau : Variables d’environnement à renseigner

Pour générer le JWT Secret, la commande suivante peut être utile

cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 32 | head -n 1

Les sources du projet sont disponibles sur Github

Tout d’abord, la génération du PDF final était pour moi quelque chose que je souhaitais de façon automatique. Je voulais pouvoir disposer à tout moment de 3 versions présentables. Une version dite de “travail”, sur laquelle je retrouve toutes mes notes en cours, une version numérique, avec des marges assez faibles, et une version papier avec des marges plus importantes, pour permettre une meilleure lisibilité lors de l’impression. J’ai donc utilisé Travis CI afin de pouvoir générer ces 3 documents à chaque tag sur mon dépôt.

J’ai également cherché à appliquer les bonnes pratiques LaTeX, avec l’utilisation du paquet nag qui permet de relever certaines erreurs et propose des corrections pour ces dernières.

Pour faciliter une diffusion plus facile de mon mémoire, j’ai mis en place une redirection vers la dernière version disponible accessible via le lien suivant : https://memoire.epsi.sylvainmetayer.fr

Un changement important à noter est le changement de ma problématique, afin d’éviter un potentiel hors-sujet et de me restreindre à un périmètre trop petit. La nouvelle problématique est la suivante : Comment l’automatisation peut-elle permettre d’améliorer le cycle de vie d’une application ?. Concernant le travail sur mon mémoire, j’ai finalisé le plan, qui comporte donc 3 parties.

1. Le cycle de vie d’une application
2. L’intérêt de la mise en place d’une démarche d’automatisation, via une étude de cas
3. L’automatisation du cycle de vie d’une application

La première partie est désormais bien avancée et la deuxième partie nécessite encore un peu de travail et de reformulation. La troisième partie dispose de la plupart des idées et concepts que je souhaite aborder, il ne restera plus qu’à l’écrire.

Prochaine deadline, 28 juin, où je présenterai une version (normalement) finalisée à mon tuteur. Comme indiqué dans l’article précédent, je suis preneur de vos retours, tant sur le fond que sur la forme !

J’ai donc décidé de rédiger sur ce blog les avancées de mon mémoire, afin de permettre de garder une trace des étapes de réalisation de ce dernier.

L’objectif est de publier un article, même court, par semaine, indiquant les recherches effectuées, les difficultés rencontrées, notes diverses et variées…

Au niveau des différents jalons imposés, les voici :

• [x] 29 mars - premier point sur mon mémoire avec mon tuteur EPSI
• [ ] 26 avril - 2ème point sur mon mémoire avec mon tuteur EPSI
• [ ] 31 mai - 3ème point sur mon mémoire avec mon tuteur EPSI
• [ ] 28 juin - 4ème point sur mon mémoire avec mon tuteur EPSI
• [ ] 15 juillet - Rendu du mémoire
• [ ] Début septembre - Soutenance de mémoire

Concernant le document attendu pour le premier rendez-vous tuteur, voici ci-dessous les éléments attendus.

Le contexte de l’alternance ainsi que les activités menées en stage ou alternance et le sujet principal des missions d’alternance

J’effectue mon alternance au sein de onepoint.

Le projet sur lequel je travaille actuellement comporte une équipe de 5 personnes, et nous effectuons le MCO^{note 1} ainsi que l’ajout de fonctionnalités d’une application web de certification et d’audit pour un client, Bureau Veritas. Cette application est développée avec Symfony (PHP) pour le back-office et AngularJS pour le front-office. De plus, l’architecture du projet est basée sur Docker.

Le back-office était initialement en Symfony 2, et nous avons procédé à sa montée de version, passant ainsi de PHP5 à PHP7 et de Symfony 2.8 à Symfony 3.4.

Également, j’interviens ponctuellement sur le front-office, après avoir reçu une formation en interne, pour des correctifs mineurs.

J’ai également mis en place un LDAP avec un container Docker dans l’environnement de développement, afin de pouvoir tester le comportement du LDAP sans avoir à atteindre les tests en recette ou en plateforme d’intégration.

J’ai auparavant travaillé sur 2 projets.

Le premier était un projet pour un client qui restera inconnu, pour des clauses commerciales liées au contrat. Ce projet consistait à la refonte d’un espace membre, avec un système de souscription, d’avantage, de quiz et de campagne email avec l’aide d’Adobe Campaign. Ce projet a été réalisé avec Drupal 8, un CMS^{note 2} PHP.

Le second projet est un ensemble de sous-projets, consistant à la refonte des sites de la région Nouvelle-Aquitaine, également sous Drupal 8. Ce choix était une contrainte client, puisque tous les utilisateurs (rédacteurs, traducteurs, …) sont déjà habitués à l’interface d’administration de Drupal 7, et qu’un changement aurait impliqué des frais de formation à un nouvel outil, pas forcément nécessaire et valable.

Les sites auxquels j’ai participé sont la refonte du site des transports de la région ainsi que la première version d’une régie publicitaire.

Le sujet ou projet d’étude envisagé

Concernant mon avancée, j’ai défini mon sujet, qui est le suivant : Comment l’automatisation peut permettre de réduire les erreurs humaines dans la mise en oeuvre d’une application ?

Ce sujet va donc concerner en grande partie le déploiement et l’intégration continue d’une application (web, étant donné qu’il s’agit du domaine dans lequel je travaille), du poste du développeur, en passant par les tests automatisés, intégration, recette, pré-production et jusqu’à la phase de production.

Néanmoins, je compte également aborder le sujet de l’automatisation au sein d’une équipe de développeurs, afin de faciliter le travail de chacun, et réduire les potentielles erreurs manuelles, que ce soit au niveau des hooks git, des linters, de l’automatisation possible avec des IDE, …

Je compte également parler de l’automatisation au niveau de l’entreprise, sa mise en place, les personnes réticentes à convaincre pour mettre en place de tels systèmes, le pour et le contre, ainsi que les impacts possibles sur les KPI^{note 3}.

Les compétences professionnelles acquises ou en cours d’acquisition pour ce sujet ou projet d’étude

Ce sujet sera donc assez théorique, mais portera également une partie pratique.

D’une part avec la légère expérience personnelle que j’ai avec ce domaine, où j’ai automatisé certains projets, tels que par exemple un chatbot réalisé en 4ème année, ou encore ma découverte d’Ansible, avec lequel j’ai automatisé l’installation d’un serveur Debian.

D’autre part avec le projet sur lequel je suis en train de travailler lors de mon alternance à onepoint. L’objectif est de faire plus ou moins une refonte, ou du moins une amélioration de la chaîne d’industrialisation.

Ce projet va être pour moi une opportunité de pouvoir me confronter à des problématiques réelles d’entreprises, et monter en compétences sur tous les domaines concernant l’intégration et le déploiement continu. Ce projet devrait être lancé dans les semaines à venir.

Une ébauche de plan

Une première ébauche de plan a déjà été effectuée en décembre, et a continué d’être agrémentée d’idées, remaniée, …

Le brouillon est disponible sur Github, et en voici son contenu, à ce jour :

0. Introduction
1. Historique
2. Pourquoi automatiser
3. État de l’art
4. Automatiser un projet
   1. Localement
   2. Intégration continue
   3. Déploiement continu
   4. Tests
5. Bénéfices constatés
6. Limites
7. Conclusion

Le PDF de l’état actuel de mon mémoire peut être consulté ici

Une première liste bibliographique détaillée

Je suis ainsi en train de lire deux livres :

• The Phoenix Project, plus sur la partie gestion de projet, qui aborde les interactions entre les différentes personnes impliquées dans un projet, et les conditions de succès d’un projet.
• The DevOps Handbook, que je viens de commencer, traitant du monde DevOps, et de la façon de déployer des applications de façon continue.

De plus, le livre Le plan Copenhague est un livre numérique, en cours de rédaction, très intéressant sur la façon de migrer des sites sous “Le cloud”.

Le site 12Factor contient également des ressources intéressantes.

Je prévois également de lire un livre traitant d’Ansible, afin d’en savoir plus à ce sujet.

Voici pour cette première édition à propos de mon avancée sur mon mémoire.

Si vous avez des retours ou idées d’amélioration, remarques constructives, n’hésitez pas à laisser un commentaire ou [contactez-moi](mailto:?subject=Commentaire sur le mémoire) !

Je souhaitais utiliser FontAwesome sans pour autant intégrer toute la librairie, assez lourde.

J’ai donc cherché un moyen de n’inclure que les icônes utilisées, et c’est comme cela que je suis venu à chercher comment créer un plugin Jekyll.

La documentation est assez bien fournie, ce qui m’a permis de rapidement prendre en main Jekyll.

Réalisation

Ne souhaitant qu’afficher des icônes, je me suis tourné vers 2 Tag, qui permettent de définir une balise et de lui passer des paramètres.

Ainsi, je passe à mon premier tag le type de l’icône que je souhaite utiliser (regular, solid ou brand), ainsi que son nom, et je génère la balise HTML^{note 1} correspondant à l’icône. Il ne me reste donc plus qu’à récupérer la définition SVG^{note 2} de l’icône et l’inclure dans un namespace, en bas de la page HTML.

Pour cela, j’ai ajouté aux données de la page Jekyll les icônes que j’utilise, dans un simple tableau.

C’est lors de l’usage du deuxième tag que je récupère toutes les icônes utilisées sur la page, et que je vais récupérer la définition SVG de l’icône.

J’ai tout d’abord réalisé ce plugin très simplement, en utilisant le répertoire _plugins de Jekyll. Mais une fois fonctionnel, j’ai souhaité en faire une Gem, mise à disposition sur RubyGems, pour qu’elle soit disponible pour tous, si elle venait à être utile à certains :blush:.

La création d’une Gem a été assez simple, le guide de Bundler étant très bien détaillé.

J’ai essayé d’être le plus en accord avec les conventions du langage Ruby, mais n’étant pas familier avec ce dernier, je suis ouvert à toutes remarques pour améliorer le code !

Il me reste à tester l’application de façon plus détaillée et à gérer les cas d’erreurs, qui sont pour le moment gérés de façon optimiste !

Usage

L’usage est le suivant :

Lorsque l’on souhaite afficher une icône, il faut utiliser le tag suivant. Le code ci-dessous va générer l’icône Twitter.

{% fa_svg fab.fa-twitter %}

Voici le résultat :

{% fa_svg fab.fa-twitter %}

Il faut ensuite ajouter à un endroit commun à toutes les pages (en général un footer), le tag de génération de la feuille SVG.

{% fa_svg_generate %}

Liens

Si vous voulez voir le code, il est disponible sur ce dépôt.

Pour télécharger la Gem, c’est par ici !

Comme indiqué dans l’article précédent, je cherchais désormais à intégrer une solution de commentaire, tout en évitant les solutions peu respectueuses de notre vie privée.

Mon choix s’était alors porté sur isso, bien qu’il existe de nombreuses alternatives^{note 1}.

La chose que j’ai appréciée avec Isso, en plus du fait qu’il est libre et auto-hébergé, est qu’il ne requiert aucune inscription pour commenter. Il est possible d’indiquer son nom, site web et adresse email (qui ne sera jamais publiée), chaque champ étant optionnel. Une modération est également possible (étant donné que j’ai fait le choix de laisser la possibilité de commenter anonymement, j’ai également fait le choix d’activer la modération avant publication).

Installation

L’installation a été assez simple, de nombreux tutoriels^{note 2} existent sur internet et la documentation est assez claire.

Voici les différentes étapes pour installer isso.

1. Installer les dépendances Python et virtualenv.

   Bien que virtualenv ne soit pas obligatoire, il est recommandé afin d’éviter d’interférer avec les dépendances existantes sur le système.

   sudo apt-get install build-essential python-dev python-pip virtualenv

2. Une fois les dépendances installées, on initialise un environnement virtualenv

   sudo virtualenv /opt/isso

   On active l’environnement, en tant que root.

   sudo su
   source /opt/isso/bin/activate

   Étant donné que /opt n’est pas accessible en écriture aux utilisateurs, on utilise sudo. Mais rien n’empêche de l’installer dans le répertoire personnel de l’utilisateur.

3. Installation des dépendances

   pip install isso gunicorn

   On peut désormais quitter virtualenv.

   deactivate

Configuration

On ne souhaite pas que isso soit exécuté en tant que root car s’il venait à y avoir une faille, l’attaquant aurait alors tous les droits. On va donc créer un utilisateur dédié et lui donner les droits sur les répertoires nécessaires (log et données). On crée également un répertoire /etc/isso qui contiendra les différentes configurations.

sudo adduser isso
sudo mkdir /var/lib/isso /var/log/isso
sudo chown isso:isso /var/lib/isso
sudo chown isso:isso /var/log/isso
sudo mkdir /etc/isso

Il reste maintenant à configurer Isso. Mon cas d’usage est le suivant : je souhaite avoir deux sites, un pour l’environnement de développement, l’autre pour la production. Voici ma configuration (/etc/isso/isso.cfg et /etc/isso/isso.prod.cfg).

Pour des détails sur chaque paramètre, se référer à la documentation d’isso.

[general]
dbpath = /var/lib/isso/prod.comments.db
# Etant donné que je configure plusieurs sites, il est nécessaire de mettre une valeur au champ name
name = main
host = https://sylvainmetayer.fr
max-age = 15m
# Pour recevoir les notifications de nouveaux commentaires par email
notify = smtp
reply-notifications=false
log-file =
# Permet d'accéder à une interface d'administration permettant de visualiser les commentaires et de les approuver/rejeter/supprimer.
admin_password = MySuperSecurePassword

[moderation]
enabled = true
purge-after = 30d

[server]
listen = http://localhost:8080

[smtp]
username = me@mon.email.fr
# Malheureusement, le mot de passe doit être en clair.
# Il est donc recommandé de créer un compte email dédié pour l'envoi des notifications.
password = MonMotDePasseEmail
host = mail.gandi.net
port = 587
security = starttls
# L'adresse qui reçoit les notifications
to = you@your.email.com
from = me@mon.email.fr
timeout = 10

[guard]
# Enable basic spam protection features, e.g. rate-limit per IP address (/24
# for IPv4, /48 for IPv6).
enabled = true
ratelimit = 2
direct-reply = 2
reply-to-self = false
require-author = false
require-email = false

[markup]
options = strikethrough, autolink, fenced_code, no_intra_emphasis
# default, only a, blockquote, br, code, del, em, h1, h2, h3, h4, h5, h6, hr,
# ins, li, ol, p, pre, strong, table, tbody, td, th, thead and ul are allowed.
allowed-elements =
allowed-attributes =

[hash]
# Utilisé pour générer des identicons sur les commentaires
salt = SaltDe25Caractère
algorithm = pbkdf2

La configuration pour le site de développement est identique, il suffit donc de copier/coller le fichier et d’éditer quelques champs.

[general]
dbpath = /var/lib/isso/dev.comments.db
name = development
host = https://development_url

sudo chown root: /etc/isso/isso.cfg
sudo chown root: /etc/isso/isso.prod.cfg

Une fois la configuration terminée, il faut configurer le service pour qu’il démarre au lancement de l’OS.

On crée donc le script de démarrage du service dans /opt/isso/isso-start.sh

#!/bin/bash
set -e
source /opt/isso/bin/activate
export LANG=C.UTF-8
export ISSO_SETTINGS="/etc/isso/isso.cfg;/etc/isso/isso.prod.cfg"
exec gunicorn -n gunicorn-isso -b 127.0.0.1:8080 --preload -w 2 --log-file /var/log/isso/isso.log isso.dispatch 2>>/var/log/isso/isso.log

sudo chown root: /opt/isso/isso-start.sh
sudo chmod 755 /opt/isso/isso-start.sh

On crée maintenant le service.

[Unit]
Description=isso commenting system

[Service]
ExecStart=/opt/isso/isso-start.sh

Restart=on-failure
TimeoutSec=1
User=isso

LimitNOFILE=16384
LimitNPROC=16384
LimitLOCKS=16384

# ensures that the service process and all its children can never gain new
# privileges.
NoNewPrivileges=true

[Install]
WantedBy=multi-user.target

On redémarre systemctl et on active isso au démarrage, puis on le lance !

sudo chown root: /lib/systemd/system/isso.service
sudo chmod 644 /lib/systemd/system/isso.service
sudo systemctl daemon-reload
sudo systemctl enable isso
sudo systemctl start isso

Il reste maintenant à configurer le reverse proxy (nginx dans mon cas).

location / {
    proxy_pass http://127.0.0.1:8080/;
    proxy_redirect default;
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-Host $host;
    proxy_set_header X-Forwarded-Server $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
}

Les headers sont importants, puisque s’ils ne sont pas présents, isso enverra des emails avec des liens pointant vers localhost:8080 et ne fonctionnera pas bien côté client.

Il ne reste maintenant plus qu’à configurer notre client ! Voici le code que j’ai ajouté dans mon fichier _layouts/post.html. J’ai également ajouté un attribut enable_comments dans mes posts, lorsque je souhaite activer les commentaires.

Le script est chargé en asynchrone, afin de ne pas gêner le chargement de la page.

{% if page.enable_comments %}
    <hr>
    <h2>Commentaires</h2>
    <script async
    data-isso="{{site.isso.url}}"
    data-isso-id="{{page.id}}"
    data-isso-feed="true"
    src="{{site.isso.script}}"></script>

    <section id="isso-thread"></section>
    <hr>
{% endif %}

Pour plus d’informations sur les paramètres disponibles côté client, voir la documentation d’isso.

⚠ Lorsqu’un fil de commentaire est vide (ce qui est le cas lorsqu’un article ne contient pas encore de commentaire), isso répond avec une erreur HTTP 404, ce qui peut faire croire qu’une page est manquante ou invalide. Une issue est ouverte sur le dépôt Github pour renvoyer un code HTTP 204 (no content) à la place.

Et voici le résultat !

Ce n’est qu’une image, les commentaires se trouvent plus bas 😉

Edit 16.07.2020 : Les commentaires ne sont pour le moment plus disponibles. Migration vers Eleventy en cours, ils devraient être remplacés à l’aide des Webmentions d’ici les prochaines semaines/mois.

Le passage de PHP à Jekyll

Après quelques années d’existence, mon ancien site commençait à vieillir.

(Les sources de mon ancien site sont toujours disponibles sur Github, mais remontent à l’époque de mon DUT, soyez indulgents ! 😁)

De plus, le premier et unique article présent sur ce site n’était même pas hébergé sur ce site, mais sur un sous-domaine (désormais inexistant) et avec la plateforme Ghost (qui est un excellent logiciel libre au passage !).

Cela faisait donc deux sites à maintenir, pour un trafic plus que faible 😀 !

Le choix de PHP avait été fait à l’époque car il s’agissait du seul langage que je maîtrisais.

En y réfléchissant, pour effectuer une refonte du site, j’ai listé les points que je souhaitais avoir.

1. Des performances améliorées

Pour cette refonte, je souhaitais obtenir des performances dignes de ce nom. N’ayant pas de logique côté serveur (puisque le but de ce site est simplement de servir du contenu, pas d’effectuer un traitement dessus ou de traiter des données externes), le choix d’un langage côté serveur ne me semblait plus très cohérent.

Étant donné que je n’ai que du contenu statique, pourquoi ne pas envoyer au client un simple fichier HTML, plutôt que de consommer du temps CPU et des processus PHP pour générer une page d’une faible complexité ? Pourquoi ne pas construire une fois toutes les pages nécessaires, pour n’avoir plus qu’à les servir ensuite, supprimant le temps de génération de la page côté serveur ?

J’ai donc commencé à creuser la question des générateurs de sites et en ai trouvé plusieurs (le très bon site StaticGen m’a beaucoup aidé à trouver des ressources et des avis). C’est ainsi que mon choix s’est porté sur Jekyll.

Voici une illustration des performances actuelles du site, ainsi qu’un rapport Dareboost. Je suis assez satisfait du résultat, même s’il me reste du travail à faire dessus (mais comme le produit parfait n’existe pas, le site parfait n’existe pas non plus ! 😜)

2. Le contenu prime sur le design (pour moi)

Je suis un très mauvais designer et l’intégration CSS est pour moi un vrai calvaire.

C’est d’ailleurs pour cela que je suis parti d’un template Jekyll que j’ai ensuite adapté à mes besoins.

Le thème de base que j’ai utilisé peut être consulté ici

Néanmoins, je ne voulais pas d’un thème complexe, qui allait ainsi influer sur les performances du site (plus il y a de CSS et de JS, plus le site sera long à charger pour l’utilisateur). C’est pourquoi le thème que j’ai choisi n’intègre aucun javascript. Ainsi, seule une feuille de style, quelques emojis provenant de Github, et une feuille SVG^{note 1} sont chargées en plus du contenu.

Je n’exclus pas d’utiliser du javascript lorsque je ferai évoluer le site, mais je vais tenter d’en limiter au maximum l’usage.

Certes, le thème du site semblera au mieux austère à certains, au pire hideux à d’autres, … Mais au moins, le site est lisible sur (presque, je n’ai pas de montre connectée pour tester !) tous les supports et charge rapidement 😀

3. La rédaction doit se faire en Markdown et une séparation style/contenu doit exister

C’est également l’une des raisons qui m’a poussé vers les générateurs de sites statiques.

J’aime beaucoup le markdown, et m’en sert beaucoup en cours pour ma prise de note. Il s’agit d’un langage extrêmement simple pour la rédaction, et en même temps, très puissant.

Concernant la séparation style/contenu, les layouts de Jekyll répondent parfaitement à ce besoin.

4. Sécurité

Je souhaitais un site qui ne sera pas facilement corrompu. Avec des pages HTML, aucune faille PHP / Node / Java / (mettez le nom de votre langage préféré ici) possible. Avec un générateur de site statique, on génère le contenu une fois, on publie le résultat et on sert le contenu, c’est tout !

Concernant l’hébergement, je me suis tout d’abord dit que j’allais profiter de l’hébergement avec Github Pages. Cela fonctionne très simplement, même avec un domaine personnel, puisqu’il suffit simplement d’utiliser le gestionnaire DNS de son registrar pour faire pointer le domaine sur l’IP de Github Page.

Néanmoins, cela a un inconvénient majeur à mon sens : la maîtrise des paramètres du site est impossible, que cela soit au niveau du cache, des headers de sécurité, … Github empêche toute modification des headers sur les sites hébergés par Github Pages^{note 2}

Au final, nous ne sommes jamais aussi bien servis que par soi-même, j’ai donc utilisé Travis CI pour déployer le site généré sur mon petit Raspberry avec un Rsync : pas besoin de plus compliqué, cela me suffit amplement. Un serveur web devant, un certificat Let’s Encrypt et voilà !

J’ai ainsi pu obtenir une note convenable, selon l’observatoire Mozilla et Cryptcheck. Il me reste néanmoins un peu de travail à faire sur les CSP (Content Security Policy), ce concept n’est pas évident à appréhender 😣 !

5. SEO

Il s’agit de ma première réelle expérience SEO^{note 3} et Jekyll offre de nombreux plugins^{note 4} permettant de générer des sitemap, un flux RSS, des métadonnées, … J’ai donc essayé de tirer profit de cela au maximum.

Workflow

Mon processus de développement est assez simple :

• Je développe en local mes articles et pages.
• Le code est versionné sur Github
• Travis s’assure de la qualité du site, avec des tests de validité des liens et des images, ainsi que la structure des pages HTML.
• Travis déploie une version (correspondant à la branche master) de production.
• Je déploie également avec une autre branche une version de développement, qui me permet de tester le site avant d’effectuer un merge sur master :smiley:

Un nouveau site, pour quoi faire

Ce site va principalement me servir à exposer mes projets réalisés, et à effectuer ma veille technologique. J’y écrirai des articles sur mes expériences de développement, afin de garder une trace de ce qui m’est arrivé. Je ne m’impose cependant aucun rythme de publication, il est donc possible que le site reste quelques mois sans nouveaux contenus.

Évolutions

Ce site est fonctionnel, mais pourtant il me reste quelques petits éléments à améliorer/régler.

Système de commentaire

Étant sur un site statique, il n’est pas possible d’inclure des commentaires directement, puisqu’il n’y a aucun traitement côté serveur.

Évidemment, il est possible d’intégrer des solutions telles que Disqus ou encore Facebook Comments mais ces solutions étant peu protectrices de notre vie privée, j’ai préféré chercher une alternative.

Après quelques recherches, j’ai trouvé 2 solutions :

1. Isso
2. Staticman

Le premier est un serveur de commentaire basique et léger écrit en Python. Je n’ai pas encore eu beaucoup de temps à consacrer à ce sujet, notamment pour l’auto-héberger, mais je pense qu’il s’agit d’une très bonne solution et risque de me pencher dessus dans les prochaines semaines !

Le deuxième semblait très prometteur mais malheureusement victime de son succès. En effet, il s’agit d’un bot Github, interagissant avec le dépôt Github, et qui ajoute les commentaires directement dans la branche master ou crée une pull request si une approbation est nécessaire avant la publication des commentaires.

De plus, comme indiqué sur leur site, cet outil s’intègre très bien avec Jekyll et Github. Néanmoins, il utilise l’API Github, et étant un projet public commençant à prendre de l’ampleur, les limitations de l’API Github semblent bloquer/ralentir ce projet, entraînant de nombreuses erreurs.

Une solution pour parer au problème serait d’auto-héberger le projet avec une clé d’API Github personnelle mais semble beaucoup pour “simplement des commentaires”, même si j’aimais beaucoup l’idée de pouvoir avoir des pull request pour chaque commentaire !

Edit : Les commentaires sont maintenant disponibles ! 💥

Voir l’article

Conclusion

Merci à tous d’avoir lu cet article, j’espère qu’il vous aura plu.

Si vous avez des remarques, n’hésitez pas à me faire vos retours !

Ce projet personnel a été réalisé pour disposer d’un modèle lors de la réalisation d’écrits avec LaTeX.

Il utilise également Travis CI afin de générer automatiquement le PDF lors du tag sur le dépôt Github et permet d’effectuer une vérification orthographique basique.

Consulter le site d’Ansible

J’ai réalisé ce projet personnel afin de me familiariser avec Ansible et pouvoir recréer un serveur à l’identique sans intervention humaine.

Le choix d’Ansible m’a semblé intéressant car il ne nécessite pas l’installation d’un agent sur le serveur cible pour effectuer le déploiement. Seul Python est requis, et la plupart, pour ne pas dire la totalité des serveurs linux disposent de python de base. De plus, la syntaxe pour écrire les playbooks (jeu d’instructions) est du YAML, simple à lire et à écrire.

J’ai tenté de réaliser les différents playbooks de la façon la plus modulaire possible, rendant l’ajout de fonctionnalités simple.

Ce projet permet ainsi de :

• Déployer un serveur et le sécuriser avec des clés SSH, Fail2Ban, Iptables.
• Déployer certaines applications réalisées lors de ma formation (afin de tester plusieurs types de déploiement, que ce soit des applications en PHP ou en NodeJS)
• Mettre en place une solution de monitoring avec Monit
• Configurer automatiquement un serveur Web (Nginx) et effectuer des demandes de certificats HTTPS auprès de Let’s Encrypt de façon automatique, y compris pour le renouvellement.

Le travail sur ce projet n’est pas encore terminé, puisqu’il reste encore par exemple à gérer la question de la sauvegarde et de la restauration des données des différentes applications installées. Vous pouvez contribuer au projet à cette adresse.

J’ai réalisé ce bot afin de permettre un suivi des interruptions des trams bordelais.

Les informations sont récupérées depuis les comptes officiels Twitter de TBM, et repère des mots clés afin de compter les jours sans interruptions.

Agent Ready

Sources (Github) Voir le jeu

Le but de ce projet était de réaliser un ‘Jeu dont vous êtes le héros’ avec diverses actions, tout en utilisant jQuery.

Ce projet a été réalisé lors de ma licence professionnelle DAWIN.

Macbernick

Sources (Github) Voir le jeu

Ce projet a été réalisé durant ma licence professionnelle DAWIN.

Il a été réalisé durant une semaine (janvier 2017) avec 6 autres étudiants et nous a initiés au déroulement d’un projet agile, de l’idée à la livraison du projet.

Il s’agit d’un jeu sur navigateur dans lequel on joue contre l’ordinateur (plusieurs niveaux de difficulté) ou à 2 joueurs (localement) pour obtenir le plus de points possible.

Tetris

Sources (Github) Télécharger le jeu (plus maintenu, plus disponible)

Projet universitaire réalisé afin de se familiariser avec le développement d’application Android.

Le but était de réaliser un Tetris. Le jeu a ensuite été publié sur le PlayStore et est disponible au téléchargement.

Semaine Innovante

Sources (Github)

La semaine innovante fait partie de la formation DAWIN, durant laquelle le but est de réaliser une application innovante.

Une grande liberté nous a été donnée pour réaliser les projets et nous avons eu à disposition différents outils.

Nous avons travaillé sur le fitbit, et plus particulièrement le Fitbit Charge 2 qui intègre un capteur cardiaque. Nous avons ainsi réalisé une application permettant d’effectuer un test de Ruffier et d’afficher les résultats en récupérant les données via l’API de Fitbit.

Open innovation

25 février 2019

Sources (Github) Tester l’application (plus maintenue, plus disponible)

Ce projet, réalisé en équipe, s’inscrivait dans la démarche Open Innovation de l’EPSI, impliquant plusieurs promotions et nécessitant donc d’être organisé. L’objectif était de réaliser un jeu de “Jeu dont vous êtes le héros” sur mobile, en laissant la possibilité de personnaliser simplement le parcours de jeu.

Nous avons développé la première version avec React Native afin de fournir un support pour Android et iOS.

AR-Cube

1 février 2019

Sources (Github) Testez-le sur mobile !

Ce projet, réalisé avec une équipe de 4 personnes, avait pour objectif d’être une introduction à la réalité augmentée.

À l’aide de la librairie Javascript AR.js, il fallait réaliser le dessin d’un cube en réalité virtuelle, lorsque les marqueurs étaient détectés à l’aide de la caméra du téléphone utilisé. Il fallait également que ce dernier puisse évoluer si l’on venait à bouger le téléphone.

Pour tester le résultat, imprimez le patron du cube présent sur le dépôt Github. Coloriez les faces de différentes couleurs et rendez-vous sur cette adresse depuis votre mobile. Après avoir autorisé l’usage de la caméra, pointez votre téléphone vers le patron et observez le résultat !

Earthquake

1 février 2019

Sources (Github) Voir le résultat

Ce projet, réalisé avec une équipe de 3 personnes, avait pour objectif d’être une introduction à WebGL.

À l’aide de la librairie Javascript three.js, il fallait réaliser une carte du monde indiquant les différents séismes (récupérés à l’aide de l’API Earthquake.usgs.gov) ainsi que leur gravité/épicentre.

Pong

30 septembre 2018

Sources (Github)

Ce projet, réalisé en binôme durant ma formation à l’EPSI, avait pour but de concevoir un jeu avec un système temps réel.

Nous avons donc décidé de réaliser un pong, en utilisant l’API mise à notre disposition pour ce projet.

Système Expert

20 mai 2018

Sources (Github)

Ce projet avait pour but de concevoir un système expert capable de détecter des formes (rectangle, carré, triangle, …).

Pour ce faire, nous avions à notre disposition une base de faits et de règles. Pour résoudre le problème, nous ajoutons nos faits et faisons tourner notre algorithme avec la base de règles, qui va comparer les différentes conditions et retourner la bonne réponse.

Le projet a été réalisé avec NodeJS et a été testé avec Cypress.

Bot Telegram

30 mars 2018

Sources (Github) Parler avec le Bot Bot hors ligne

Ce projet, réalisé en binôme, avait pour but de réaliser un chatbot de recrutement.

Nous avons choisi de réaliser ce bot sur la plateforme Telegram. L’objectif du bot était de poser quelques questions de développement puis de réseau afin de déterminer le niveau du candidat. Si le candidat a un niveau suffisant, alors une proposition lui est faite et il est invité à renseigner ses coordonnées pour être recontacté. Dans le cas contraire, on lui demande s’il souhaite laisser ses coordonnées afin d’être recontacté lorsque de nouvelles offres seront disponibles.

Machine Learning

20 février 2018

Sources (Github)

Ce projet, réalisé en binôme durant ma formation à l’EPSI, avait pour but de découvrir le fonctionnement des algorithmes de machine learning.

Ce que montre la vidéo : le résultat du projet. On fait un dessin dans un canvas, et l'application détecte l'emoji qui lui correspond.

Télécharger la vidéo (MP4, 1,2 Mo)

Traduction de l’article “The Parthenay Effect: How a Small French Town Might Save Civilization” paru le 27 mars 2017 sur The Huffington Post

⚠ Avertissement
Je ne suis ni traducteur, ni bilingue. Mon objectif est de fournir une traduction de cet article pour les personnes ayant des difficultés avec l’anglais. Bien qu’ayant tenté de traduire au mieux cet article, je ne peux garantir l’exactitude de ce qui suit.

Tous les droits sur cet article, ainsi que les photos, reviennent à sa rédactrice Rebecca Novick.

Le printemps dernier, j’ai déménagé à Parthenay, une ville de 11.000 habitants, ce qui est un petit peu plus qu’un village. Il est normal que vous n’en ayez jamais entendu parler. Même mes amis français ont dû chercher où cela se situait. C’est également une commune, ou plutôt ce qui est appelé une “communauté de communes” avec 6 communes voisines. Elle est située dans le département des Deux-Sèvres, au cœur de la Nouvelle Aquitaine et au sud de la vallée de la Loire. La ville de Parthenay a une beauté ancienne avec peu de lignes droites et beaucoup de paniers à fleurs et de toits en tuiles rouges. Les gens marchent souvent avec tellement de baguettes à la main que vous vous demandez comment ils peuvent toutes les manger. Il y a même des distributeurs de baguette automatiques, prêts pour ces inévitables urgences. Pour ceux qui vivent dans les villages environnants, une fourgonnette livre du pain fraîchement cuit à votre porte (vous pouvez également acheter la moitié d’une baguette pour 47 centimes). Il y a tellement de gens qui élèvent des poulets que des œufs frais sont constamment échangés entre voisins, et peu daigneraient consommer ceux élevés en batterie. Même ma maison située dans l’hyper-centre de la ville est paisible parmi ces bourdonnements d’oiseaux qui rappellent à nombre d’entre nous des souvenirs d’enfants. J’avais voyagé pendant quelques mois en Inde une fois, et j’étais habituée à beaucoup de chaos et d’agitation. Il m’a fallu quelques mois pour m’habituer à cette nouvelle tranquillité.

“C’est tellement calme ici”, disais-je à un ami. “C’est l’heure du déjeuner” me répondit-il. Puis, souriant, il ajouta : “Ça sera encore plus calme après le déjeuner.”

La seule fois où mon sommeil a été interrompu par une perturbation humaine fut durant une nuit d’été, pendant un festival de musique. J’ai été réveillée à 3 heures du matin par le bruit d’un jeune homme qui jouait de la guitare et chantait une ballade française dans la rue, sous la fenêtre de ma chambre. J’étais ici, heureuse, avant de retomber dans les bras de Morphée.

Parthenay repose dans une courbe de la rivière du Thouet, vieux français pour “Tranquille”. Établi au milieu du 11ème siècle, ses charmantes maisons médiévales et son château donnent l’impression de la terre du Milieu croisée avec le château de Tintagel (Note du traducteur : Tintagel est une localité et une paroisse civile de la côte nord-ouest du comté de Cornouailles en Angleterre.). Parthenay est située dans l’une des Gâtines de la France. Le mot ‘Gâtine’ est connu dans la légende arthurienne pour être un endroit stérile et déserté. La prophétie dit que la terre deviendra fertile une fois la quête du Saint Graal achevée. Le nom fait référence au granit rocheux qui rend l’agriculture difficile. Mais il est riche en faune. (traduction manquante). Ses haies abritent des lapins et ses chênes et hêtres sont des postes de sentinelles pour les buses. Ses champs sont remplis de moutons mais aussi de la superbe race locale de vaches, la “Parthenaise”, rousse et musclée. Les terres du Sud Deux-Sèvres sont de loin bien plus cultivables. Des champs de tournesol offrent une vue magnifique en été. Le blé, l’avoine, les pommes de terre, les pommes et les noix sont cultivés en abondance et le marché aux légumes du mercredi est rempli d’agriculteurs vendant des fromages de chèvres locaux et des tomates de la taille d’une balle de tennis. Vingt ans plus tôt, le gouvernement français payait les agriculteurs pour qu’ils laissent leur terre en jachère un an afin qu’ils puissent recommencer sans pesticides. Ce léger mouvement pour les produits bio a reçu assez peu d’attention.

Des méandres amènent sur un moulin abandonné ou sur un ruisseau bouillonnant, des chênes ou encore une église à moitié oubliée. Aucune industrie dans les environs et l’air purifiant des eaux de l’Atlantique, je n’hésite pas à inspirer profondément l’air de Gâtine dans mes poumons. J’ai vécu à Londres, Los Angeles et New Delhi. Ici, je peux respirer d’une façon que j’avais presque oubliée. J’ai un jour été choquée de voir une canette de Coca-Cola flotter dans le Thouet. C’était parce que ce déchet était une aberration que je l’ai remarqué.

J’ai vécu une grande partie de ma vie dans les montagnes et je pensais qu’elles me manqueraient, mais les ciels de Gâtine sont infinis, à tel point que les nuages deviennent ici des montagnes, formant les gammes de la chaîne de l’Himalaya. Le soleil prend tellement de temps à se lever que vous pouvez vous amuser des heures durant avec des palettes kaléidoscopiques de violet, vermillon, topaze et magenta. Une étendue non obstruée vers l’Ouest offre aux habitants de la Gâtine ce que j’appelle “Le second soleil”, surtout en été. Alors que le soleil descend, aux alentours de vingt heures, il tombe souvent derrière une nuée de nuages mais comme il n’y a pas de bâtiment bloquant la vue à l’horizon, il réémerge une demi-heure plus tard, offrant jusqu’à deux heures supplémentaires de sa lumière. Cette topographie explique pourquoi Parthenay enregistre le deuxième plus grand temps d’ensoleillement dans toute la France. Ce ciel spacieux et le peu de pollution lumineuse sont faits pour les amateurs d’astronomie. Une fois, en août, un groupe d’amis et moi avons conduit jusqu’à un endroit surnommé la “colline du lapin” et avons regardé en silence les météores des Perséides exécuter leur ballet argenté à travers le firmament.

Parthenay et ses environs ont été en grande partie protégés du développement rongeant le monde moderne. Après avoir échappé à la pollution et à l’architecture sans âme, les Parthenaisiens (habitants de Parthenay) ont aussi surpassé les nombreuses formes de cynismes et narcissismes ravageant le psychisme moderne. Le rythme de vie est simple, respectueux, calme, et cela fournit le cadre parfait pour cette espèce en voie de disparition, le temps.

Je me promène régulièrement ici, en explorant les passages étroits et les escaliers de pierre qui relient la ville ensemble, tout en jetant un œil aux vieilles portes en bois qui s’ouvrent sur les vergers de pommiers et les jardins d’herbes médiévales. Je m’allonge dans l’herbe et j’entends les chants des grives et des merles, l’odeur de l’herbe et de la terre dans mes narines. Je me sens comme j’ai autrefois été une enfant. J’ai entrepris des projets photos avec Parthenay comme sujet. Elle est profondément photogénique mais sans la vanité des grandes villes françaises. Je l’étudie sous différentes lumières et différentes saisons, sous beaucoup d’angles, et j’écris à propos d’elle dans mon blog, le “Projet Parthenay”. La ville a été nommée Ville d’Arts et d’Histoire. De nombreux artistes vivent ici, un nombre impressionnant de professeurs de Yoga et de Qi Gong ainsi qu’une communauté d’invalides indépendante.

Alors que je me promène dans les rues le soir, ma caméra à mes côtés, les chats sautent des murs, se frottent contre mes jambes pour une caresse. Les locaux sont assis dans des cafés sirotant le café noir en parcourant les journaux locaux ou en partageant une blague sur les minuscules verres de Rosé (à la différence des Britanniques, les Français tiennent l’alcool. À ce jour, je n’ai entendu qu’une histoire d’état d’ivresse sur la voie publique, ce qui a alimenté les conversations des semaines durant, tellement cela était rare).

Il est tout à fait normal de saluer plutôt que d’ignorer un étranger ici. Même les jeunes vous saluent lorsque vous leur passez devant.

Mais la ville ne prospère pas. Les enseignes ferment à un rythme alarmant et presque toutes les rues sont à vendre, les vitrines converties en mini galeries d’art. Les anciennes industries textiles ont disparu, ainsi que le train, qui a transporté ses derniers passagers il y a 23 ans. Une zone commerciale à la périphérie de la ville a aspiré la quasi-totalité des commerces du centre-ville. (traduction manquante). Les quelques touristes qui arrivent à cet endroit (au détour d’une sortie en vélo le plus souvent) marchent comme s’ils avaient trébuché sur leur propre conte de fées. Parthenay est une beauté endormie, attendant d’être réveillée.

Pourtant, cela n’a pas toujours été le cas. Parthenay était autrefois une ville marchande, capitale de la Gâtine Vendéenne. Pendant des siècles, c’était une étape importante sur le Camino de Compostela, le pèlerinage à la crypte de Saint Jacques, censé avoir le pouvoir de pardonner tous les péchés, qui traversait toute la France et se terminait à la Cathédrale de Santiago de Compostela au nord-ouest de l’Espagne. Depuis les années 1980, le Camino, ou la “voie” a connu une renaissance spectaculaire attirant près de 300.000 pèlerins modernes par an, venant du monde entier. L’itinéraire original prenait des mois à effectuer, mais de nos jours, même les plus aventureux commencent leur voyage près de la frontière espagnole, le long des Pyrénées, sur la frontière française. Pourtant, j’imagine des réfugiés du fascisme arrivant comme des pèlerins par l’ancienne voie de la Porte Saint Jacques, qui se dresse au-dessus de la rivière, accueillant les naufragés de cette triste civilisation en déclin.

Les matins d’automne, la brume recouvre les rues et les champs. La ville fortifiée de Parthenay est construite sur une légende. Il est dit qu’elle a été créée par la baguette d’une femme magique, nommée Mélusine. Il y a trois couches de fortifications faites à partir de granit. En effet, c’est un endroit digne de protection. Il y a plus une éthique de vie qu’une éthique de travail ici. La seule chose ouverte le dimanche est l’église. Les déjeuners durent deux à trois heures et sont considérés comme un moment sacré. Même les restaurants sont fermés le lundi et beaucoup ne sont ouverts que quelques heures par semaine, avec des écriteaux sur leurs portes disant “Heure d’ouverture 14-17h le mercredi”. Oui, il peut être compliqué de faire quelque chose. Mais ça va, puisqu’il y a le temps de le faire ici.

Est-ce que j’exagère ? Oui, mais seulement un peu. Bien sûr, de mauvaises choses arrivent, même à Parthenay. Il y a de la méchanceté ici également. Il y a des commérages et de la jalousie. Ce n’est pas pour tout le monde. Il n’y a pas d’hypermarché, seulement une petite salle de cinéma, et peu de grandes chaînes industrielles. L’heure de pointe sont quelques Peugeot qui se bousculent pour une place. Pas même un Starbucks (chut !), ce qui est ironique puisque leur logo est basé sur la dame à queue de poisson, Mélusine, elle-même. Mais il y a plus que ça. Je suis d’un côté effrayée d’en parler, et de l’autre effrayée de ne pas en parler. Si la ville dort, pourquoi ne pas la laisser dormir ? Récemment, un de mes amis discutait à propos d’hylozoïsme, la théorie comme quoi les objets inanimés auraient une conscience et peuvent, dans une certaine mesure faire leurs propres choix. Une ville peut-elle choisir ses résidents ? J’aime à penser que les pierres et brouillards de Parthenay sont en quelque sorte capables de décider qui vient, et qui pourra s’installer ici. Comme nos gouvernements continuent de nous décevoir, nous devons créer plus de communautés intentionnelles dans le monde.

Pour moi, Parthenay est comme un refuge dans cette tempête. Ici, j’apprends à dérouler les nœuds de mon passé, à embrasser la paix sous toutes ses formes. Je me souviens de la maison d’Elrond dans le Seigneur des Anneaux qui accueillait les voyageurs épuisés et leur fournissait un endroit où ils pouvaient retrouver leur énergie ainsi que leur inspiration. Comme l’écrit Tolkien, ‘Si seulement il y avait une cure pour la fatigue, la peur et la tristesse.’

Parthenay est ma maison d’Elrond. Pourrait-elle être la vôtre ?

Le projet a été réalisé en Python avec une équipe de trois personnes.

J’ai travaillé avec les méthodes agiles (SCRUM) afin de réaliser un outil capable de s’adapter à plusieurs SGBDR.

La nuit de l’info réunit étudiants, enseignants et entreprises afin de réaliser en une nuit une application web sur un thème national donné.

Accompagné d’une équipe de 14 personnes, j’ai eu l’occasion de participer à l’édition 2015 à Bordeaux.

J’ai également participé à l’édition 2016 de cet évènement, toujours à Bordeaux, accompagné d’une équipe de 10 personnes.

Bataille navale

Source (Github) Version Graphique (.jar)

Réalisé en binôme entre mars et mai 2015, ce projet nous a permis de nous familiariser avec Java Swing et de constituer nos premières interfaces graphiques.

Le jeu se joue à deux joueurs, avec la possibilité de sauvegarder les parties.

Il était demandé de réaliser une version console et une version graphique du jeu.

Bêtisier de l’IUT

Source (Github) Voir le site

Ce projet universitaire constituait une découverte du PHP. Il consistait à réaliser un site rassemblant les perles de profs, permettant leur ajout, notation par des élèves, …

Un module d’administration était également demandé, afin de gérer entre autres les utilisateurs, et mettre un système de modération sur les citations.

Ce projet a été réalisé entre octobre et décembre 2015.

GEMAO

Sources (Gitlab)

GEMAO^{note 1} est un projet tuteuré qui consistait à réaliser une application permettant la gestion d’une école de musique avec JavaEE.

Il s’agissait de la continuité d’un projet commencé l’année dernière par un autre groupe d’étudiants.

Réalisé en groupe (5 étudiants) pour l’école de musique Anacrouse, située à La Chapelle Saint Ursin, de septembre 2015 à avril 2016.

Pygame

Source (Github)

Ce projet universitaire consistait à réaliser un mini-jeu en réseau, à l’aide des librairies PyGame et PodSixNet.

Il a été réalisé entre février et avril 2016.

Ce mémoire détaille le travail réalisé durant mon stage au sein de NextMedia, effectué d’avril à juillet 2016.

J’y ai réalisé la refonte de l’administration du site vitrine de la société, ainsi qu’un gestionnaire de version pour le produit phare de la société : un boîtier de vote interactif, Quizzbox. Ce site permet ainsi aux différents clients de Quizzbox de pouvoir télécharger les versions du logiciel sur une plateforme, et d’avoir un suivi des mises à jour disponibles.

Pour ce projet, j’ai également été amené à générer des miniatures à partir d’un document PowerPoint, pour pouvoir afficher un aperçu du document sur le site.