# Self-host your own services
A series of 7 article(s), in reading order.
# Outil de monitoring auto-hébergé
> Découvrez comment installer facilement Uptime Kuma, un outil de monitoring de sites web gratuit et auto-hébergé, avec une simple commande Docker. Suivez la disponibilité de vos sites, assurez la persistance des données et configurez les notifications.
---
**TL;DR**
Cet article montre comment auto-héberger Uptime Kuma, un dashboard gratuit de monitoring de sites web, avec une seule commande `docker run` (en montant un volume pour conserver les sites surveillés entre les redémarrages), puis comment configurer les vérifications site par site et les notifications (par exemple via Mattermost ou par email) quand un site tombe.
Imaginez : vous êtes développeur web ou vous travaillez dans une agence web et vous aimeriez garder un œil, gratuitement, sur les sites que vous avez développés pour vos clients. Ces sites sont-ils en ligne en ce moment, ou sont-ils down ?
C'est le travail des plateformes de monitoring de sites. Pouvez-vous en installer une sur votre machine ? Bien sûr !
Il existe des tonnes d'*outils de monitoring auto-hébergés* ; l'un d'eux est [Uptime Kuma](https://github.com/louislam/uptime-kuma). Vous pouvez jouer avec le site de démonstration ici : . Créez simplement un compte admin (gratuitement) et vous êtes prêt à ajouter vos premiers sites.
Comme indiqué dans la [documentation officielle](https://github.com/louislam/uptime-kuma#-docker), vous pouvez le démarrer facilement avec la commande ci-dessous.
```bash
$ `docker run -d --restart=always -p 3001:3001 -v \${PWD}:/app/data --name uptime-kuma louislam/uptime-kuma:1`
```
> Screenshot — http\://localhost:3001
>
> 
> **N'oubliez pas d'ajouter un volume:**
>
> Le flag `-v ${PWD}:/app/data` (un [volume](/blog/docker-volume)) est important si vous voulez conserver les sites que vous ajouterez au dashboard (c'est-à-dire si vous redémarrez l'outil). Si vous voulez juste jouer une fois avec l'interface, vous pouvez l'omettre : rien ne sera écrit sur le disque.
Dans la page des paramètres, site par site, vous pouvez définir de nombreuses actions, comme ce que l'outil de monitoring doit faire quand le site est down. Par exemple, vous envoyer une notification sur *Mattermost*, un email ou ...
> **Il y a tellement de paramètres à configurer:**
>
> En plus des éléments de configuration site par site, vous trouverez aussi dans la page *Profile -> Settings* un grand nombre de paramètres globaux, comme le choix de la langue de l'interface (le français est disponible).
Uptime Kuma surveille vos sites **depuis l'extérieur**. Pour ce qui se passe sur votre propre machine, [Get health information from your running containers](/blog/docker-healthy) fait le même travail pour vos containers. Et une fois que vous auto-hébergez quelques outils de ce genre, [Heimdall](/blog/heimdall-dashboard) est une chouette façon de les rassembler sur une seule page d'accueil.
---
# Comment auto-héberger Matomo
> Auto-hébergez Matomo gratuitement et obtenez des statistiques de fréquentation conformes au RGPD. Ce guide simple couvre l'installation, la configuration de la base de données et l'intégration avec Docusaurus.
---
**TL;DR**
Cet article explique comment auto-héberger Matomo, un outil d'analyse web conforme au RGPD, sur un sous-domaine : téléchargement et décompression de la release via SSH, création d'une base de données MySQL, exécution de l'assistant d'installation et, enfin, mise en place du script de tracking — y compris le plugin `docusaurus-plugin-matomo` pour les sites Docusaurus.
[Matomo](https://matomo.org) est un outil de tracking conforme au RGPD pour votre site web. J'ai enfin décidé de l'installer pour obtenir les chiffres de fréquentation du blog ; savoir quels articles sont les plus lus, quels sujets intéressent le plus, etc., pas seulement par curiosité mais aussi pour mieux cerner mon audience.
J'ai choisi la [solution auto-hébergée](/blog/docker-memos) (parce qu'elle est gratuite) afin que mes chiffres de fréquentation restent sur mon propre serveur.
L'installation est un jeu d'enfant : télécharger un fichier zip, le décompresser et lancer l'assistant. Vraiment facile.
Il existe un bon tutoriel sur .
De mon côté, voici les actions que j'ai menées :
1. Créer un sous-domaine `matomo.avonture.be` pointant vers un dossier précis sur mon host.
2. Créer un certificat SSL pour le sous-domaine.
3. Se connecter à ce nouveau dossier en SSH
* Lancer `wget https://builds.matomo.org/matomo.zip` pour télécharger la dernière version
* Lancer `unzip -o matomo.zip` pour décompresser et récupérer les fichiers
* Lancer `rm -f matomo.zip "How to install Matomo"` pour supprimer deux fichiers inutiles
Comme je savais qu'il me fallait une base de données MySQL, je suis allé sur mon dashboard. Pour [PlanetHoster](/blog/planethoster-n0c-spam), c'est et là, j'ai créé une nouvelle base MySQL et son utilisateur.
Enfin, il ne me reste plus qu'à lancer l'assistant sur `https://matomo.avonture.be/index.php` et suivre le guide.
L'assistant est vraiment bien fait et très simple à suivre.
Une fois terminé, j'obtiens mon dashboard sur et il ne me reste qu'à ajouter le script de tracking à mes pages, comme expliqué dans l'assistant.
## Docusaurus {#docusaurus}
Sur [ce blog](/blog/docusaurus-docker-own-blog), j'utilise [Docusaurus](https://docusaurus.io/) donc j'ai installé un plugin pour ça : .
---
# Installer LimeSurvey avec Docker
> Apprenez à installer LimeSurvey rapidement et facilement avec Docker Compose. Un guide complet sur la mise en place, la persistance des données avec les volumes et l'exécution de versions spécifiques.
---
**TL;DR**
Cet article montre comment démarrer LimeSurvey, un outil de sondage open source, avec Docker Compose et l'image `martialblog/docker-limesurvey`. Il couvre une configuration minimale pour faire tourner le site sur `http://localhost:8080`, l'ajout de volumes pour que vos sondages et votre configuration survivent aux redémarrages du container, et le fait de figer LimeSurvey et MySQL sur des versions précises quand vous devez reproduire localement un ancien environnement de production.
LimeSurvey est un outil de sondage open source qui permet de créer et de mener des enquêtes en ligne. C'est un outil puissant et intuitif, utilisable par tout le monde.
Une fois de plus, il est facile de jouer avec et de créer un site bac à sable pour découvrir toutes ses fonctionnalités ; merci Docker.
*Deux choses sur lesquelles repose ce `compose.yaml` et qui sont expliquées ailleurs sur ce blog : [les volumes](/blog/docker-volumes), pour que vos sondages survivent au redémarrage d'un container, et [les healthchecks](/blog/docker-healthy), pour que LimeSurvey attende que MySQL accepte réellement les connexions.*
Pour cela, nous allons utiliser l'image Docker .
## LimeSurvey, opérationnel en deux minutes {#limesurvey-running-in-two-minutes}
Un fichier `compose.yaml`, un `docker compose up --detach`, et voici ce qui vous attend sur `http://localhost:`8080`/admin` :
> Screenshot — http\://localhost:8080/admin
>
> 
Une installation LimeSurvey complète — liste des sondages, participants, statistiques — qui tourne sur votre machine, sans rien installer à part Docker. Construisons-la.
## À nous de jouer {#lets-play}
Ouvrez un shell Linux et lancez `mkdir -p /tmp/limesurvey && cd $_` pour créer un dossier `limesurvey` dans votre dossier temporaire Linux et vous y rendre.
Créez ensuite un fichier `compose.yaml` dans ce dossier avec ce contenu :
**compose.yaml**
```yaml
name: limesurvey
services:
limesurvey-app:
image: docker.io/martialblog/limesurvey:latest
container_name: limesurvey-app
restart: always
environment:
- DB_TYPE=mysql
- DB_HOST=limesurvey-db
- DB_NAME=limesurvey
- DB_USERNAME=admin
- DB_PASSWORD=admin
- ADMIN_USER=admin
- ADMIN_PASSWORD=admin
- ADMIN_NAME=admin
- ADMIN_EMAIL=admin@example.com
ports:
- 8080:8080
depends_on:
limesurvey-db:
condition: service_healthy
limesurvey-db:
image: docker.io/mysql:8.4
container_name: limesurvey-db
environment:
- MYSQL_USER=admin
- MYSQL_PASSWORD=admin
- MYSQL_ROOT_PASSWORD=root
- MYSQL_DATABASE=limesurvey
healthcheck:
test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
timeout: 10s
retries: 10
```
Il suffit maintenant de lancer la commande suivante pour télécharger (uniquement la première fois) les images nécessaires (LimeSurvey et MySQL) et créer les deux containers :
```bash
$ docker compose up --detach
```
Une fois tout téléchargé et démarré, vous pouvez vérifier que vous avez bien deux containers en lançant la commande suivante :
```bash
$ docker container list
[...] IMAGE [...] NAMES
[...] martialblog/limesurvey:latest [...] limesurvey-app
[...] mysql:8.4 [...] limesurvey-db
```
> **La sortie ci-dessus a été simplifiée:**
>
> Pour plus de clarté, la sortie de `docker container list` a été simplifiée ci-dessus ; toutes les colonnes ne sont pas reprises dans l'article.
La condition `service_healthy` dans le fichier compose garantit que LimeSurvey ne démarrera pas avant que MySQL soit prêt, ce qui élimine les erreurs de connexion dont vous avez peut-être entendu parler dans de vieux tutoriels. Patientez tout de même **une ou deux minutes** (selon votre machine) le temps que LimeSurvey initialise les tables de sa base de données.
Rendez-vous sur `http://localhost:`8080 et si vous voyez `ERR_CONNECTION_REFUSED`, attendez encore un peu et rafraîchissez. Quand c'est prêt, vous devriez voir la page d'accueil par défaut de LimeSurvey.
> **Regardez les logs:**
>
> Si l'attente se prolonge et que quelque chose semble anormal, lancez `docker compose logs -f` pour inspecter les logs. Vous devriez voir `[core:notice] [pid 1] AH00094: Command line: 'apache2 -D FOREGROUND'` quand LimeSurvey est prêt, ce qui signifie que le serveur web est lancé et accepte les connexions.
>
> Appuyez sur `CTRL`-`C` pour arrêter de suivre les logs.
## Première connexion {#first-login}
Quand LimeSurvey est prêt, vous verrez la page suivante sur `http://localhost:`8080 :
> Screenshot — http\://localhost:8080
>
> 
Allez sur `http://localhost:`8080`/admin` pour ouvrir l'interface d'administration. Les identifiants à utiliser sont `admin` / `admin` (comme défini dans le fichier `compose.yaml`, voir les variables `ADMIN_USER` et `ADMIN_PASSWORD`).
> Screenshot — http\://localhost:8080/admin
>
> 
Une fois connecté, vous arrivez sur le tableau de bord montré au début de cet article, et vous êtes prêt à jouer avec LimeSurvey sur votre machine.
## Utiliser des volumes {#using-volumes}
Le fichier `compose.yaml` fourni plus haut n'utilisait aucun volume : quand vous arrêterez les containers, votre travail sera perdu et LimeSurvey redémarrera sans configuration ni sondages, comme après une réinitialisation complète.
Si vous voulez tester LimeSurvey sur plusieurs jours et conserver vos éléments de configuration et vos sondages, vous voudrez garder votre travail. Pour cela, vous devez utiliser des volumes.
Voici un fichier `compose.yaml` mis à jour pour demander à Docker d'utiliser des volumes qu'il gère lui-même.
**compose.yaml**
```yaml
name: limesurvey
services:
limesurvey-app:
image: docker.io/martialblog/limesurvey:latest
container_name: limesurvey-app
restart: always
environment:
- DB_TYPE=mysql
- DB_HOST=limesurvey-db
- DB_NAME=limesurvey
- DB_USERNAME=admin
- DB_PASSWORD=admin
- ADMIN_USER=admin
- ADMIN_PASSWORD=admin
- ADMIN_NAME=admin
- ADMIN_EMAIL=admin@example.com
# highlight-next-line
volumes:
# highlight-next-line
- limesurvey:/var/www/html/upload/surveys
ports:
- 8080:8080
depends_on:
# highlight-next-line
limesurvey-db:
# highlight-next-line
condition: service_healthy
limesurvey-db:
image: docker.io/mysql:8.4
container_name: limesurvey-db
# highlight-next-line
volumes:
# highlight-next-line
- data:/var/lib/mysql
environment:
- MYSQL_USER=admin
- MYSQL_PASSWORD=admin
- MYSQL_ROOT_PASSWORD=root
- MYSQL_DATABASE=limesurvey
# highlight-next-line
healthcheck:
# highlight-next-line
test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
# highlight-next-line
timeout: 10s
# highlight-next-line
retries: 10
# highlight-next-line
volumes:
# highlight-next-line
limesurvey:
# highlight-next-line
data:
```
> **Envie d'en savoir plus sur les volumes ?:**
>
> Dans ce cas, lisez cet article : [Using volumes with Docker, use cases](/blog/docker-volumes)
## Télécharger une ancienne version {#download-an-old-version}
> **Cette section fige MySQL 5.7, qui est en fin de vie:**
>
> MySQL 5.7 est en fin de vie depuis octobre 2023 et ne reçoit plus de correctifs de sécurité. Le figer est volontaire ci-dessous, car tout l'intérêt est de reproduire un ancien environnement de production sur votre machine. **N'utilisez jamais `mysql:5.7` pour autre chose que la reproduction locale d'une installation legacy.**
Vous savez quoi ? Télécharger une ancienne version est vraiment simple.
Imaginons la situation suivante : vous devez intervenir sur une ancienne installation de LimeSurvey. Pour l'exemple, disons que vous devez installer un plugin quelconque mais, évidemment, avant de le faire sur un site de production, vous allez vous salir les mains en local. Il vous faut donc télécharger la même version que celle de production.
Plus tôt dans cet article, nous avons vu qu'on pouvait facilement télécharger la version « latest ».
Recommençons, mais cette fois pour une version précise. En regardant le site de production, vous voyez par exemple la version `3.22.6+200219`.
Dans notre `compose.yaml`, nous devons alors remplacer `image: docker.io/martialblog/limesurvey:latest` par autre chose, mais par quoi ? Un tag valide, à coup sûr. Allez sur et, dans la zone `Filter Tags`, tapez `3.22.6`, notre version de production donc. Nous obtenons trois images, mais une seule pour `apache` (en effet, nous voulons utiliser l'image Docker contenant à la fois PHP et Apache). Bingo, nous savons maintenant que notre ligne sera `image: docker.io/martialblog/limesurvey:3.22.6_200219-apache`.
La deuxième partie, c'est de savoir avec certitude quelles lignes mettre dans le fichier yaml. Pour cela, rendez-vous simplement sur et essayez de retrouver la même release. Ici, c'est : .
Cliquez par exemple sur `Source code (zip)` pour télécharger l'archive et ouvrez-la. Récupérez le fichier `compose.yaml` depuis l'archive et regardez attentivement comment il est configuré.
Par exemple, nous voyons que la version de MySQL utilisée à l'époque était `mysql:5.7` (utilisez donc la même pour éviter les conflits).
Notre `compose.yaml` devient alors :
**compose.yaml**
```yaml
name: limesurvey
services:
limesurvey-app:
image: docker.io/martialblog/limesurvey:3.22.6_200219-apache
container_name: limesurvey-app
restart: always
environment:
- DB_TYPE=mysql
- DB_HOST=limesurvey-db
- DB_NAME=limesurvey
- DB_USERNAME=limesurvey
- DB_PASSWORD=secret
- ADMIN_USER=admin
- ADMIN_PASSWORD=admin
- ADMIN_NAME=admin
- ADMIN_EMAIL=admin@example.com
ports:
- 8080:80
depends_on:
limesurvey-db:
condition: service_healthy
limesurvey-db:
image: mysql:5.7
container_name: limesurvey-db
environment:
- MYSQL_USER=limesurvey
- MYSQL_PASSWORD=secret
- MYSQL_ROOT_PASSWORD=secret
- MYSQL_DATABASE=limesurvey
healthcheck:
test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
timeout: 10s
retries: 10
```
Lancez simplement `docker compose up --detach` puis rendez-vous sur `http://localhost:`8080 et, félicitations, vous avez un site LimeSurvey v3.22.6 en local.
## Conclusion {#conclusion}
Deux services dans un `compose.yaml`, une condition `service_healthy` pour que LimeSurvey attende sa base de données, et quelques volumes nommés quand vous voulez que vos sondages survivent : c'est tout ce qu'il faut pour obtenir un LimeSurvey jetable — ou persistant — sur votre propre machine. Et comme la version n'est qu'un tag Docker, reproduire exactement la release qui tourne en production ne demande qu'une seule ligne à modifier.
Même recette, autres outils : parcourez les articles [self-hosted](/blog/tags/self-hosted) de ce blog.
---
# Heimdall - Dashboard web
> Fatigué des vieux favoris de votre navigateur ? Découvrez comment auto-héberger et configurer Heimdall, un superbe dashboard web qui vous donne un accès immédiat et personnalisé à toutes vos applications et liens préférés via Docker.
---
**TL;DR**
Fatigué de vos favoris de navigateur en désordre ? Cet article présente Heimdall, un dashboard web auto-hébergeable et agréable à l'œil pour organiser vos applications et liens préférés. Apprenez à déployer Heimdall rapidement avec Docker et un simple fichier `compose.yaml`. Le guide vous accompagne dans la configuration initiale : personnaliser l'apparence, créer des tags d'organisation et ajouter vos premières applications. Il explique aussi comment faire en sorte que la configuration de votre dashboard survive à la suppression du container.
>
Je n'ai jamais été un grand fan des favoris du navigateur et, de fait, je n'en ai presque aucun. Et, assez logiquement, je n'affiche presque jamais la barre des favoris.
Je ne visite régulièrement que quelques sites et l'historique de mon navigateur s'en souvient ; sinon, un célèbre moteur de recherche s'en souvient pour moi.
Cela dit, je ne suis pas contre une page d'accueil personnalisée et Heimdall me convient très bien pour le moment.
Heimdall est une application web que vous pouvez auto-héberger (et c'est un jeu d'enfant avec Docker) sur votre ordinateur.
Voici la démo officielle :
Vous allez définir le look\&feel de votre page d'accueil en indiquant les liens auxquels vous voulez un accès immédiat et, pour les autres, vous les classerez dans des dossiers. Rien de compliqué.
Mais cela vous donne une manière bien plus agréable d'accéder à vos sites que la gestion dépassée des favoris. C'est peut-être une des choses qui n'ont pas changé depuis trente ans.
## Créer votre dashboard {#creating-your-dashboard}
Créez un dossier de test et placez-vous dedans :
```bash
$ mkdir ~/tools/dashboard && cd $_
```
Dans ce dossier, créez un fichier appelé `compose.yaml` avec le contenu suivant (voir la [page officielle Docker Hub](https://hub.docker.com/r/linuxserver/heimdall/) pour la dernière version) :
**compose.yaml**
```yaml
# cspell:disable
name: tools
services:
heimdall:
image: lscr.io/linuxserver/heimdall:latest
container_name: heimdall
environment:
- PUID=${USER_ID:-1000}
- PGID=${GROUP_ID:-1000}
- TZ=Europe/Brussels
volumes:
- ./config:/config
ports:
- 80:80
- 443:443
restart: unless-stopped
```
> **Note:**
>
> Dans le code ci-dessus, j'ai préféré la syntaxe `PUID=${USER_ID:-1000}` et `PGID=${GROUP_ID:-1000}` plutôt que de coder en dur `1000` : sur mon ordinateur, mon id utilisateur Linux est `1002` et pas `1000`, donc je préfère utiliser une variable et, si elle n'est pas définie, utiliser `1000` par défaut. Pareil pour l'id du groupe.
## Lancer le dashboard {#running-the-dashboard}
Une fois le fichier `compose.yaml` créé, lancez simplement cette commande : `USER_ID=$(id -u) GROUP_ID=$(id -g) docker compose up --build --detach`.
Cette commande va définir nos deux variables `USER_ID` et `GROUP_ID`, les initialiser avec vos propres valeurs puis démarrer le container.
> **Note:**
>
> Si vous avez codé les IDs en dur dans le fichier `compose.yaml`, par ex. `1000` (parce que vous savez que ce sont vos IDs), alors la commande devient plus courte : `docker compose up --build --detach`
## Premier lancement {#first-run}
Une fois la commande `docker compose up --build --detach` lancée, le container est déjà créé, c'est-à-dire que vous pouvez déjà aller sur `http://localhost` pour voir le résultat.
> Screenshot — http\://localhost
>
> La page d'accueil par défaut
Amusons-nous : cliquez sur le dernier bouton en bas à droite (l'icône des paramètres) et, sous `Appearance`, chargeons une nouvelle image de fond.
> Screenshot — http\://localhost
>
> Mon propre fond d'écran
C'est beaucoup plus sympa, non ?
### Sauvegarder la configuration sur le disque {#saving-the-configuration-on-disk}
Avez-vous remarqué que, dans le fichier `compose.yaml`, il y a une section appelée `volumes` avec la configuration suivante ?
**compose.yaml**
```yaml
volumes:
- ./config:/config
```
Cela signifie que le dossier `config` de Heimdall sera stocké sur votre disque, dans un dossier appelé `config` lui aussi. *C'est le [mécanisme des volumes](/blog/docker-volume) en action.*
Je peux le vérifier en lançant `ls -alh` sur mon host :
```bash
Permissions Size User Group Date Modified Name
drwxr-xr-x - christophe christophe 2025-01-26 10:36 config
.rw-r--r-- 284 christophe christophe 2025-01-26 10:36 compose.yaml
```
Et donc, tout ce que je ferai dans Heimdall sera sauvegardé sur mon ordinateur. Autrement dit, si je dois arrêter et supprimer le container Docker, il me suffira de le relancer pour retrouver tous mes réglages.
### Ajouter quelques liens {#adding-some-links}
Je vous suggère, avant d'ajouter de nouveaux liens, de cliquer d'abord sur l'icône Tags (la cinquième icône en bas à droite) parce que vous allez organiser vos liens avec des tags et qu'il faut donc créer les tags d'abord.
> Screenshot — http\://localhost
>
> Ajouter des tags
Ajoutez autant de tags que vous voulez. Pour ce tutoriel, je n'en crée qu'un.
Quand c'est fini, cliquez sur le bouton `Cancel` en haut à droite ou sur le quatrième bouton en bas à droite (appelé `Application list`).
Créez une nouvelle application. Vous pouvez choisir entre un `Application type` et un `Website`. Dans mon usage actuel, je choisis toujours `Website`. Je remplis ensuite l'URL et je clique sur `Go`.
Heimdall va extraire le favicon en différentes tailles. Je clique sur celle que je veux.
> Screenshot — http\://localhost
>
> Ajouter Docker
Heimdall a automatiquement rempli quelques propriétés dans la partie basse de l'écran. Je vais retirer `Home dashboard` de la zone `Tags` et taper `Docker` à la place, c'est-à-dire le tag que j'ai créé précédemment.
> Screenshot — http\://localhost
>
> Ajouter Docker
Après sauvegarde, j'obtiens ma nouvelle page d'accueil :
> Screenshot — http\://localhost
>
> Page d'accueil avec Docker
On voit que les tags sont représentés comme des dossiers. Si je clique dessus, j'*entre* dans le *dossier* et je vois toutes les applications portant ce tag.
Je peux aussi ajouter des applications qui apparaîtront directement sur la page d'accueil (comme des raccourcis sur votre bureau). Pour cela, créez une nouvelle application et gardez `Home dashboard` dans la liste des tags.
Explorons cette fonctionnalité `Application Type` :
> Screenshot — http\://localhost
>
> Type d'application
C'est juste une sorte de snippet. Si je sélectionne `Bitwarden` là-dedans, Heimdall va faire quelques initialisations de base : il va remplir le champ `Application name` et l'icône. Bon, pourquoi pas.
Je fais pointer l'URL vers `https://vault.bitwarden.com/#/login` et je garde `Home dashboard` comme tag.
> Screenshot — http\://localhost
>
> Avec Bitwarden
Voici le dashboard que j'utilise au travail. Comme c'est très facile d'ajouter de nouveaux éléments, je le modifie dès que je travaille sur un nouveau projet.
> Screenshot — http\://localhost
>
> Dashboard Heimdall final
### Plus de personnalisations {#more-customizations}
En cliquant sur la dernière icône en bas à droite, vous pouvez personnaliser encore quelques éléments dans Heimdall. Vous pouvez afficher par ex. un moteur de recherche, ce qui est pratique.
Vous pouvez personnaliser le CSS et ajouter du JS aussi.
## Pour aller plus loin {#continue-your-journey}
Visitez le site officiel pour les mises à jour et la documentation.
Deux autres applications auto-hébergées que je fais tourner à côté de Heimdall : [Uptime Kuma](/blog/docker_uptime_kuma), pour savoir quand un de ces liens est hors service, et [Memos](/blog/docker-memos) pour la prise de notes.
Trouvez l'inspiration en cherchant **dashboard heimdall homepage** dans [Google Images](https://www.google.com/search?sca_esv=e645136bb336bc61\&q=dashboard+heimdall+homepage\&udm=2).
---
# Excel Formula Beautifier
> Rendez vos formules Excel complexes faciles à lire ! Utilisez l'Excel Formula Beautifier pour formater et clarifier instantanément les formules de vos feuilles de calcul.
---
**TL;DR**
Vous peinez à lire et à déboguer de longues formules Excel complexes ? Cet article présente l'« Excel Formula Beautifier », un petit outil web qui transforme instantanément vos formules alambiquées en un format propre, indenté et facile à comprendre. Collez votre formule, cliquez sur un bouton, et la logique apparaît clairement, ce qui facilite grandement l'analyse et le dépannage.
Pouvez-vous lire `=IF(AND(A1<100,B1<>"",ISNUMBER(SEARCH("abc",C1))),TEXT(D1,"dd-mm-yyyy")&" - "&ROUND(E1/F1,2),"N/A")` sans vous dire : ok, prenons quelques secondes pour analyser la formule et comprendre ce qu'elle fait ? Moi, non : je dois m'arrêter un moment et prendre le temps de lire avant de comprendre.
Il y a des années, pour le plaisir, j'ai créé . Il rejoint la petite famille d'outils de formatage auto-hébergés que j'ai construits au fil du temps, comme mon [SQL Formatter](/blog/sql-formatter).
Découvrons-le.
## Comment l'utiliser {#how-to-use}
Une image vaut mille mots...
> Screenshot — https\://excel-formatter.avonture.be/
>
> Demo
Copiez/collez donc simplement votre longue formule dans la première zone de texte et cliquez sur le bouton Beautify.
> **Information:**
>
> Le script va essayer de déterminer si le séparateur utilisé est `,` ou `;` et, en cas de souci, il suffit d'indiquer le bon.
Vous obtiendrez ce type de résultat :
```none
=IF(
AND(
A1 < 100;
B1 <> "";
ISNUMBER(
SEARCH(
"abc";
C1
)
)
);
TEXT(
D1;
"dd-mm-yyyy"
) & " - " &
ROUND(
E1 / F1;
2
);
"N/A"
)
```
C'est plus clair, non ? Sinon, voici la transcription :
Si :
* `A1` est inférieur à `100`,
* `B1` n'est pas vide et
* `C1` contient `abc`,
Alors :
`D1` sera formaté comme une date européenne, suivie d'un ratio arrondi de `E1`/`F1`.
Sinon :
Renvoie `N/A`.
---
# karakeep - L'application pour tout mettre en favori
> Découvrez karakeep, le gestionnaire auto-hébergé de favoris, de notes et d'images. Suivez ce guide simple pour l'installer avec Docker Compose.
---
**TL;DR**
Cet article présente karakeep, une application auto-hébergée tout-en-un pour gérer favoris, notes et images, avec un moteur de recherche redoutable. Le guide propose un tutoriel pas à pas pour installer karakeep via une configuration Docker Compose personnalisée. Il explique comment configurer le fichier `compose.yaml` pour stocker les données sur la machine hôte et définir les bonnes permissions utilisateur. Après l'installation, l'article détaille la création du premier utilisateur et montre les fonctions clés : ajouter de nouveaux éléments et les organiser en listes hiérarchiques.
Depuis quelques mois, j'utilise [Heimdall](/blog/heimdall-dashboard) mais cet outil a une grosse faiblesse : son moteur de recherche hyper basique (voire inexistant, puisqu'il n'est pas possible de rechercher un lien de manière globale).
J'étais donc plutôt insatisfait et j'attendais de trouver mieux : karakeep.
C'est un outil que vous pouvez auto-héberger et qui est un gestionnaire de favoris, de notes et même d'images, tout en restant très simple.
*Il rejoint le petit ensemble d'outils auto-hébergés que j'utilise tous les jours, à côté de [Memos](/blog/docker-memos) et [Uptime Kuma](/blog/docker_uptime_kuma) — tous regroupés dans Docker Desktop grâce à l'astuce décrite dans [Docker - How to group containers together](/blog/docker-name-property).*
Et le moteur de recherche est plutôt puissant. Globalement, karakeep est un plaisir à utiliser.
Voyons-le à l'œuvre.
## Ajouter un favori {#add-a-bookmark}
Une fois karakeep lancé, ajouter quelque chose est un jeu d'enfant : cliquez dans la zone de texte **New Item** et commencez à taper (ça peut être du texte brut comme un pense-bête, ou l'URL d'un site web).
Je vais taper `https://awesome-docker-compose.com/apps`, enregistrer et j'obtiens immédiatement ceci :
> Screenshot — http\://localhost:2000/dashboard/bookmarks
>
> 
Comme vous le voyez, karakeep a récupéré une image de la page web — pas de vignette à ajouter à la main, aucune étape supplémentaire.
## Pourquoi ça fonctionne {#why-it-works}
* Une seule barre de recherche couvre à la fois les favoris, les notes et les images — précisément ce qui me manquait et qui m'a poussé à chercher un remplaçant.
* Enregistrer un lien capture automatiquement un aperçu de la page : une liste de favoris reste visuelle, ce n'est pas un mur d'URL nues.
* Notes, images et liens vivent dans les mêmes listes hiérarchiques : plus besoin de jongler avec trois applications auto-hébergées différentes pour trois tâches liées.
* C'est auto-hébergé, donc vos favoris et vos notes restent sur votre propre disque, à côté des autres outils dans [Heimdall](/blog/heimdall-dashboard).
## Installons karakeep {#lets-install-karakeep}
Créez un dossier avec `mkdir ~/tools/karakeep && cd $_`. Dans ce dossier, créez un fichier `compose.yaml` avec le contenu ci-dessous :
**compose.yaml**
```yaml
# cspell:disable
name: tools
services:
web:
image: ghcr.io/karakeep-app/karakeep:${KARAKEEP_VERSION:-release}
restart: unless-stopped
volumes:
- ./data:/data
ports:
- 2000:3000
env_file:
- .env
user: ${UID:-1000}:${GID:-1000}
environment:
MEILI_ADDR: http://meilisearch:7700
BROWSER_WEB_URL: http://chrome:9222
DATA_DIR: /data
chrome:
image: gcr.io/zenika-hub/alpine-chrome:123
restart: unless-stopped
command:
- --no-sandbox
- --disable-gpu
- --disable-dev-shm-usage
- --remote-debugging-address=0.0.0.0
- --remote-debugging-port=9222
- --hide-scrollbars
meilisearch:
image: getmeili/meilisearch:v1.13.3
restart: unless-stopped
env_file:
- .env
environment:
MEILI_NO_ANALYTICS: "true"
volumes:
- meilisearch:/meili_data
volumes:
meilisearch:
```
> **Note:**
>
> La ligne `user: ${UID:-1000}:${GID:-1000}` demande à Docker d'utiliser un utilisateur spécifique (pas `root`) lors de la création des fichiers sur votre disque.
>
> L'utilisateur `1000:1000`, c'est vous dans la plupart des cas, c'est-à-dire votre utilisateur Linux actuel (tapez `id -u` puis `id -g` pour récupérer votre ID utilisateur et votre ID de groupe, et vous verrez que ce sera `1000` pour les deux).
>
> Si vos IDs ne sont pas `1000`, éditez le fichier yaml et mettez les vôtres à la place.
> **Information:**
>
> Par rapport à la configuration Docker par défaut, j'ai fait un changement : stocker les données sur le disque dur plutôt que d'utiliser un volume Docker.
>
> J'ai dû réinstaller karakeep après un changement de configuration et j'ai dû exporter le volume pour récupérer les données (Docker Desktop propose cette fonction).
>
> Pour éviter cette situation, autant garder directement les fichiers sur mon disque dur.
Une fois le fichier `compose.yaml` créé, dans votre console, il suffit de lancer `docker compose up --build --detach`.
karakeep tourne maintenant. Rendez-vous sur `http://localhost:`2000`/` et vous obtiendrez cet écran :
> Screenshot — http\://localhost:2000/
>
> 
Comme c'est votre première fois, cliquez sur `Sign Up` et créons un nouvel utilisateur. karakeep imposera des règles au mot de passe, alors une fois défini, n'oubliez pas de l'ajouter dans votre gestionnaire de mots de passe (Bitwarden pour ma part).
Vous arrivez sur le tableau de bord :
> Screenshot — http\://localhost:2000/dashboard/bookmarks
>
> 
## Ajouter à une liste {#adding-to-a-list}
Créez d'abord une liste et remplissez les différentes options (nom, icône, ...) :
De retour sur le tableau de bord, cliquez sur le bouton `...` de l'élément souhaité puis sur l'option `Manage Lists` pour pouvoir créer une nouvelle liste :
Il est aussi possible de créer une liste comme enfant d'une liste existante et donc d'obtenir facilement quelque chose comme ceci :
### Astuce - Sélectionnez une liste avant d'ajouter un élément {#tips---select-a-list-before-adding-an-item}
Si vous sélectionnez d'abord une liste, les nouveaux éléments y seront ajoutés directement.
## Fonctions supplémentaires {#extra-features}
### Import / Export {#import--export}
En cliquant sur l'avatar de votre profil (en haut à droite) puis sur `User Settings`, vous accéderez, entre autres, à une fonction `Import / Export`. C'est bon à savoir : vous pouvez importer depuis de nombreuses sources et aussi exporter en JSON ou en page HTML.
## Conclusion {#conclusion}
karakeep a remplacé la recherche inexistante de Heimdall par une seule barre qui couvre favoris, notes et images, et il fait ce qu'un simple gestionnaire de favoris ne fait pas : il capture un aperçu visuel de chaque lien enregistré. Un `compose.yaml`, deux lignes d'UID/GID, et il tourne à côté de [Memos](/blog/docker-memos) et [Uptime Kuma](/blog/docker_uptime_kuma) dans la même stack auto-hébergée.
Consultez le site officiel pour plus d'infos, et [Docker - How to group containers together](/blog/docker-name-property) pour le garder bien rangé à côté de vos autres outils auto-hébergés.
---
# Application de prise de notes auto-hébergée
> Déployez rapidement l'application de prise de notes auto-hébergée memos avec Docker. Découvrez ses fonctionnalités simples - Markdown, checklists, tags et collage d'images.
---
**TL;DR**
Cet article présente « memos », une application de prise de notes auto-hébergée, légère et simple, parfaite pour les rappels et les tâches quotidiennes d'un développeur. Le guide détaille pas à pas l'installation de memos avec une configuration Docker Compose personnalisée, en insistant sur la persistance des données et les bonnes permissions de fichiers. Vous verrez comment démarrer, créer des notes en Markdown et avec des checklists, les organiser avec des tags et utiliser des filtres avancés appelés « shortcuts ». L'article met aussi en avant des fonctionnalités pratiques comme le collage direct d'images dans vos notes.
Comme développeur, je travaille toute la journée sur un ordinateur et parfois (trop souvent en fait), en fin de journée, je m'envoie un email pour le moi de demain : *N'oublie pas de ...*, *tu dois continuer \[une tâche]*, *je me suis arrêté à \[un fichier], je dois continuer les autres*. Bref, j'utilise ma boîte de réception comme un gestionnaire de to-dos / pense-bêtes.
Peut-on faire mieux ? Bien sûr, mais quel outil choisir ?
Ce que j'aimerais : pouvoir écrire des notes très facilement, que certaines notes soient des tâches (une case à cocher me suffit) et pouvoir copier/coller des images comme une capture d'écran.
Idéalement, j'aimerais avoir un site web local que je peux consulter chaque jour comme pense-bête.
La simplicité est la clé.
Il existe énormément d'applications mais, comme j'ai vraiment besoin d'un outil simple et rapide (c'est la fin de journée, je dois filer prendre mon train, hop hop, quelques secondes, ok, la note pour demain est créée), j'ai essayé **[memos](https://www.usememos.com/)** et je l'apprécie beaucoup.
## Installons memos {#lets-install-memos}
Cette fois, je ne vais pas proposer d'utiliser le dossier temporaire puisque nous devrons conserver nos notes, nos images collées, ... sur notre disque pendant les prochains jours, semaines ou mois. *Cela se fait avec un [Docker volume](/blog/docker-volume) : le container peut être détruit et recréé, vos notes restent sur votre disque.*
Lancez donc `mkdir -p ~/tools/memos && cd $_` pour créer un dossier dans votre répertoire personnel et vous y rendre.
Ensuite, créez un fichier appelé `compose.yaml` avec ce contenu :
**compose.yaml**
```yaml
name: tools
services:
memos:
image: neosmemo/memos:stable
container_name: memos
init: true
user: ${UID:-1000}:${GID:-1000}
ports:
- "5230:5230"
volumes:
- ./data:/var/opt/memos
restart: unless-stopped
```
> **Note:**
>
> La ligne `user: ${UID:-1000}:${GID:-1000}` demande à Docker d'utiliser un utilisateur spécifique (pas `root`) lors de la création de fichiers sur votre disque.
>
> L'utilisateur `1000:1000`, c'est vous dans la plupart des cas, c'est-à-dire votre utilisateur Linux actuel (tapez `id -u` puis `id -g` pour récupérer votre ID utilisateur et votre ID de groupe et vous verrez que ce sera `1000` pour les deux).
>
> Si vos IDs ne sont pas `1000`, éditez le fichier yaml et mettez les vôtres à la place.
Dans votre console, maintenant, lancez simplement `docker compose up --build --detach`.
En six secondes à peine, memos a été installé sur ma machine et un container a été créé :
Rendez-vous sur `http://localhost:`5230 et vous verrez que le site tourne déjà :
> Screenshot — http\://localhost:5230
>
> 
> **Information:**
>
> Regardez en bas à gauche ; il est possible de choisir une autre langue ; le français est supporté par exemple.
Je vais créer mon compte (`admin/admin` puisque je travaille sur mon localhost) et je suis prêt à créer ma première note. Ça m'a pris moins d'une minute jusqu'ici.
> Screenshot — http\://localhost:5230
>
> 
Cliquez dans la zone d'édition `Any thoughts...` et commencez à taper votre idée... Par exemple :
```markdown
**Python Codebase - User Authentication Module:**
- [ ] Implement password hashing using bcrypt.
- [ ] Create user registration endpoint (`/register`).
- [ ] Develop user login endpoint (`/login`) with JWT token generation.
```
> Screenshot — http\://localhost:5230
>
> 
En appuyant sur le bouton `Save`, la note est créée. C'est propre et, demain, oh chouette, oh oui, c'est vrai, j'ai ces trois choses à faire.
Imaginez qu'on soit demain et que j'aie terminé la première : il me suffit de cocher la case et c'est sauvegardé automatiquement :
> Screenshot — http\://localhost:5230
>
> 
Je peux toujours éditer, épingler, supprimer, archiver, ... la tâche via le bouton à trois points :
## Créons quelques tâches en plus {#lets-create-a-few-more-tasks}
Comme vous le voyez, même si c'est optionnel, assignons un ou plusieurs tags à une note. Simplement en utilisant la syntaxe avec le dièse :
```markdown
**Python Codebase - User Authentication Module:** #python
- [x] Implement password hashing using bcrypt.
- [ ] Create user registration endpoint (`/register`).
- [ ] Develop user login endpoint (`/login`) with JWT token generation.
```
```markdown
Investigate and resolve the bug in the budgetary application that occurs when initializing a new financial exercise. #budget
```
```markdown
Write the missing documentation for the new user authentication module, covering API endpoints, data models, and setup instructions. #python
```
```markdown
Review the Dockerfile for the user authentication service to ensure optimal image size and security practices. #docker #python
```
> Screenshot — http\://localhost:5230
>
> 
## Filtrer avec les tags {#filtering-using-tags}
Quand vous avez utilisé des tags, vous les voyez immédiatement en bas à gauche sous `Tags`. Cliquez simplement sur un tag pour filtrer dessus. Vous pouvez en cliquer plusieurs si vous voulez. Dans l'exemple ci-dessous, j'ai trois notes pour `Python` et une seule avec le tag Docker :
> Screenshot — http\://localhost:5230/?filter=tagSearch%3Apython%2CtagSearch%3Adocker
>
> 
## Créer des shortcuts {#creating-shortcuts}
En plus des tags, vous pouvez utiliser des filtres plus sophistiqués, ce que memos appelle des `shortcut`.
Le filtre utilisé est `has_task_list && tag in ["python"]`.
Maintenant, cliquez simplement sur le filtre pour l'activer. Vous ne verrez qu'une seule tâche (parce que les autres notes avec le tag `python` n'avaient pas de case à cocher). Vraiment facile non ?
[En savoir plus sur l'écriture des filtres](https://usememos.com/docs/usage/shortcuts)
## Coller des images {#pasting-images}
Comme dans n'importe quelle application moderne, copiez l'image dans le presse-papier et collez-la dans la zone de texte. Ajoutez du texte si vous le souhaitez.
## Personnalisation {#customization}
En cliquant sur l'icône de profil en bas à gauche, vous pouvez modifier les paramètres de l'application, par exemple définir `Monday` comme premier jour de la semaine (pour le calendrier en haut à gauche).
Vous pouvez aussi injecter du CSS / JavaScript pour personnaliser l'apparence de memos.
## Conclusions {#conclusions}
Comme annoncé en introduction, personnellement, c'est plus que suffisant pour mes besoins. Je voulais quelque chose d'ultra-simple (un onglet dans mon navigateur) et la possibilité d'écrire mes notes très vite (avec le support de Markdown), d'avoir des cases à cocher et de pouvoir copier/coller une capture d'écran.
Memos va un cran plus loin avec la gestion des tags et des shortcuts, et la possibilité de restreindre la to-do list à une période du calendrier.
Et tout ça est 100% gratuit !
## Plus d'infos {#more-info}
Consultez le site officiel pour plus d'informations.
*Deux autres outils auto-hébergés qui tournent à côté de memos sur ma machine : [Heimdall](/blog/heimdall-dashboard), le dashboard depuis lequel je les ouvre tous, et [Uptime Kuma](/blog/docker_uptime_kuma) pour le monitoring.*
---