Databases, Systems & Networks

Vous avez des serveurs, une box domotique, un NAS ou quelques conteneurs Docker, et vous voulez voir d’un coup d’œil ce qui s’y passe : charge CPU, mémoire, températures, consommation électrique, logs ? Grafana est l’outil de référence pour ça. Dans cet article, je vous explique à quoi il sert, pourquoi il vaut le coup, et comment l’installer en quelques minutes avec Docker.

Qu’est-ce que Grafana ?

Grafana est une application web libre (open source) de visualisation de données et de supervision. Elle ne stocke pas vraiment vos données : elle se branche sur des sources de données (Prometheus, InfluxDB, Loki, MySQL/MariaDB, PostgreSQL, Elasticsearch, etc.) et vous permet de construire des tableaux de bord composés de graphiques, jauges, tableaux, cartes ou indicateurs.

Lire la suite…

Les piles de courriers, les factures glissées dans un tiroir et les contrats introuvables au moment où l’on en a besoin ont une solution libre et gratuite : Paperless-ngx. Cet article explique ce que fait ce logiciel, pourquoi il vaut la peine d’être installé chez soi, et comment le déployer avec Docker Compose.

Qu’est-ce que Paperless-ngx ?

Paperless-ngx est un système de gestion électronique de documents (GED) libre, conçu pour l’auto-hébergement. Vous lui donnez un PDF ou une photo de document : il en extrait le texte par reconnaissance optique de caractères (OCR), l’indexe, propose un classement et conserve l’original à côté d’une version archivée.

Le projet est la suite communautaire de Paperless et de Paperless-ng. Il se déploie avant tout avec Docker, et l’image est publiée sur le registre de conteneurs GitHub.

Pourquoi l’adopter

Retrouver un document par son contenu

L’OCR rend le texte de chaque page interrogeable. Plus besoin de se rappeler du nom du fichier ou du dossier : la barre de recherche retrouve « contrat chaudière » ou un numéro de client à l’intérieur même d’un scan.

Un classement qui se fait presque tout seul

Chaque document peut recevoir des étiquettes, un correspondant (l’émetteur), un type de document et un chemin de stockage. Des règles de correspondance, ou un apprentissage à partir de vos propres classements, attribuent ces métadonnées automatiquement aux nouveaux documents. Le tri manuel se limite aux cas inédits.

Une porte d’entrée pour tous vos papiers

• Dossier surveillé : tout fichier déposé dans le dossier consume est traité. Un scanner réseau qui envoie vers un partage SMB ou NFS suffit à alimenter la GED.
• Boîtes e-mail : des règles de messagerie récupèrent les pièces jointes (factures, relevés) et les classent.
• Glisser-déposer depuis l’interface web, et une API REST pour les automatisations et applications tierces.

Des documents vivants, pas un simple dépôt de PDF

Champs personnalisés (montant, échéance, numéro de compte), notes, versions d’un document, vues enregistrées affichées sur le tableau de bord, workflows déclenchés à l’arrivée ou à la modification d’un document : l’outil sert aussi de pense-bête administratif, par exemple pour suivre les factures impayées.

Vos données restent chez vous

Aucun abonnement, aucun envoi vers un cloud tiers : les documents sont stockés sur votre serveur. L’application gère plusieurs utilisateurs avec des droits par document, ce qui permet de partager une GED familiale tout en gardant certains dossiers privés. Le contenu est stocké dans des formats ouverts, et un export complet est intégré.

Prérequis

• Un serveur ou mini-PC sous Linux (ou un NAS compatible Docker) ; Paperless-ngx tourne sur architectures amd64, arm et arm64.
• Docker et le plugin Docker Compose (docker compose). Suivez le guide d’installation officiel de Docker pour votre distribution.
• De la marge en mémoire et en processeur : l’OCR est gourmand, surtout lors de l’import d’une grosse archive. Prévoyez plusieurs Go de RAM libres.
• De l’espace disque pour les originaux et les versions archivées, soit grossièrement le double de vos fichiers.

Installation avec Docker Compose

Deux voies existent. Dans les deux cas, on obtient la même pile de trois conteneurs : webserver (l’application), db (PostgreSQL, recommandé pour une nouvelle installation) et broker (file de tâches Valkey, compatible Redis).

Option 1 : le script d’installation (le plus rapide)

Le projet fournit un script interactif qui pose quelques questions (port, dossier de données, base de données, fuseau horaire, langue de l’OCR, utilisateur administrateur), télécharge les fichiers et lance la pile :

bash -c "$(curl -L https://raw.githubusercontent.com/paperless-ngx/paperless-ngx/main/install-paperless-ngx.sh)"

Attention : comme pour tout script lancé directement depuis Internet, lisez-le d’abord (par exemple avec curl -L …/install-paperless-ngx.sh | less) pour voir ce qu’il fait.

Option 2 : installation manuelle, pas à pas

Cette voie donne la maîtrise complète des fichiers et s’intègre mieux à une gestion par dépôt Git ou par Portainer.

1. Créer le dossier du projet

sudo mkdir -p /opt/paperless/{consume,export}
sudo chown -R $USER:$USER /opt/paperless
cd /opt/paperless

2. Récupérer les fichiers officiels : le compose PostgreSQL, le fichier d’environnement et le fichier .env qui fixe le nom du projet.

B=https://raw.githubusercontent.com/paperless-ngx/paperless-ngx/main/docker/compose
curl -fsSL $B/docker-compose.postgres.yml -o docker-compose.yml
curl -fsSL $B/docker-compose.env          -o docker-compose.env
curl -fsSL $B/.env                        -o .env

Pour lire aussi les documents Office (Word, Excel, LibreOffice), prenez à la place le fichier docker-compose.postgres-tika.yml, qui ajoute les conteneurs Tika et Gotenberg.

3. Vérifier le docker-compose.yml. Voici, sans ses commentaires, la version officielle au moment de la rédaction :

services:
  broker:
    image: docker.io/valkey/valkey:9-alpine
    restart: unless-stopped
    volumes:
      - redisdata:/data
  db:
    image: docker.io/library/postgres:18
    restart: unless-stopped
    volumes:
      - pgdata:/var/lib/postgresql
    environment:
      POSTGRES_DB: paperless
      POSTGRES_USER: paperless
      POSTGRES_PASSWORD: paperless
  webserver:
    image: ghcr.io/paperless-ngx/paperless-ngx:latest
    restart: unless-stopped
    depends_on:
      - db
      - broker
    ports:
      - "8000:8000"
    volumes:
      - data:/usr/src/paperless/data
      - media:/usr/src/paperless/media
      - ./export:/usr/src/paperless/export
      - ./consume:/usr/src/paperless/consume
    env_file: docker-compose.env
    environment:
      PAPERLESS_REDIS: redis://broker:6379
      PAPERLESS_DBHOST: db
      PAPERLESS_DBENGINE: postgresql
volumes:
  data:
  media:
  pgdata:
  redisdata:

Trois points à connaître :

• 8000:8000 : le port de gauche est celui exposé sur votre machine. Changez-le (par exemple 8283:8000) si 8000 est déjà pris.
• ./consume et ./export sont des dossiers visibles sur l’hôte ; data et media sont des volumes gérés par Docker. Pour garder tous les documents dans un dossier précis (un montage NAS, par exemple), remplacez media:/usr/src/paperless/media par /chemin/vers/media:/usr/src/paperless/media.
• Le mot de passe PostgreSQL par défaut est paperless. La base n’est pas exposée hors du réseau Docker, mais si vous le changez, modifiez aussi PAPERLESS_DBPASS dans le service webserver.

4. Régler le fichier d’environnement. Ouvrez docker-compose.env : seule la clé secrète est active par défaut, et elle doit être remplacée.

PAPERLESS_SECRET_KEY=remplacez-par-une-longue-chaine-aleatoire
PAPERLESS_TIME_ZONE=Europe/Paris
PAPERLESS_OCR_LANGUAGE=fra+eng
#PAPERLESS_URL=https://paperless.exemple.fr
#USERMAP_UID=1000
#USERMAP_GID=1000

Pour générer la clé : openssl rand -base64 48.

5. Télécharger les images et démarrer

docker compose pull
docker compose up -d
docker compose ps

Le premier démarrage prend une à deux minutes (migrations de la base). Suivez-le avec docker compose logs -f webserver.

6. Créer le compte administrateur

docker compose run --rm webserver createsuperuser

Saisissez l’identifiant, l’e-mail (facultatif) et le mot de passe, puis ouvrez http://ADRESSE_DU_SERVEUR:8000 et connectez-vous. Le compte créé ici est le seul au départ.

Réglages à faire dès le départ

Variable	Rôle
PAPERLESS_SECRET_KEY	Clé de signature des sessions. À changer absolument et à conserver : la modifier déconnecte tous les utilisateurs.
PAPERLESS_TIME_ZONE	Fuseau horaire utilisé pour les dates des documents (Europe/Paris).
PAPERLESS_OCR_LANGUAGE	Langues de l’OCR. fra+eng pour des documents en français et en anglais ; la valeur par défaut est eng, ce qui dégrade la reconnaissance des accents.
PAPERLESS_OCR_LANGUAGES	Paquets de langues supplémentaires à installer dans le conteneur, pour les langues absentes de l’image de base.
PAPERLESS_URL	URL publique, indispensable derrière un reverse proxy HTTPS.
USERMAP_UID / USERMAP_GID	Identifiants de l’utilisateur Linux qui doit être propriétaire des fichiers des dossiers montés (id -u et id -g).

Après toute modification du fichier d’environnement, docker compose up -d recrée le conteneur avec les nouvelles valeurs.

Premiers pas

1. Déposer des documents : glissez-les dans l’interface, ou copiez-les dans /opt/paperless/consume. Ils apparaissent après traitement, avec l’étiquette « Inbox » si elle existe.
2. Créer vos attributs dans Gérer : correspondants (EDF, impôts, banque), types (facture, contrat, relevé), étiquettes. Pour chacun, choisissez l’algorithme de correspondance : « Automatique » s’appuie sur ce que vous avez déjà classé.
3. Corriger les premiers classements : l’apprentissage automatique s’affine avec vos corrections. Quelques dizaines de documents suffisent à améliorer nettement les propositions.
4. Enregistrer des vues (documents fiscaux, factures impayées) et les épingler sur le tableau de bord.
5. Brancher le scanner ou une règle de messagerie pour automatiser l’arrivée des documents.

📷 IMAGE 6 À INSÉRER ICI : fichier paperless-06-liste-tableau.jpg (bloc Image, puis « Lier au média »). Texte alternatif : Liste des documents en tableau avec filtres par étiquette, correspondant, type et dates. Légende : Affichage en tableau : filtres par titre et contenu, étiquettes, correspondant, type de document, dates et permissions. (supprimer ce paragraphe après insertion)

Sauvegarde et mise à jour

Sauvegarder

Ne vous contentez pas de copier les volumes Docker pendant que la base tourne. Utilisez l’exporteur intégré, qui produit les fichiers d’origine, les métadonnées et un manifeste restaurable :

docker compose exec -T webserver document_exporter ../export --no-progress-bar

Le résultat se trouve dans /opt/paperless/export : copiez ce dossier vers un second support, de préférence hors de la machine. Vous pouvez planifier la commande par cron chaque nuit. Pour restaurer, le conteneur propose la commande symétrique document_importer.

Gardez aussi une copie de docker-compose.yml, de docker-compose.env (clé secrète comprise) et du fichier .env.

Mettre à jour

cd /opt/paperless
docker compose pull
docker compose up -d

Lisez les notes de version avant un changement de version majeure : certaines évolutions de la base demandent une manipulation. Pour éviter les surprises, remplacez latest par un numéro de version précis dans le fichier compose et montez-le vous-même.

Sécurité et accès distant

• Ne publiez pas le port 8000 directement sur Internet. Placez un reverse proxy HTTPS (Nginx, Apache, Caddy, Traefik) devant, et renseignez PAPERLESS_URL.
• Pour un usage purement domestique, un VPN (WireGuard, Tailscale, ZeroTier) donne accès à la GED depuis l’extérieur sans l’exposer.
• Créez un compte par personne plutôt que de partager le compte administrateur, et utilisez les permissions par document pour les dossiers sensibles.
• Vos documents contiennent des données personnelles et financières : chiffrez le support des sauvegardes.

Pour conclure

Une heure suffit pour monter Paperless-ngx : quelques fichiers, trois conteneurs, un compte administrateur. Le vrai gain vient ensuite, quand un courrier numérisé retrouve tout seul son étiquette, son correspondant et sa date. Une fois l’habitude prise, le papier passe au scanner dès son arrivée et la question « où ai-je mis cette facture ? » disparaît.

Liens

• Documentation officielle de Paperless-ngx
• Dépôt GitHub de Paperless-ngx (licence GPL-3.0)

Si votre maison brûle ou est cambriolée, pourrez-vous dire à votre assureur ce que vous possédiez, combien ça valait et où c’était rangé ? La plupart d’entre nous répondraient « à peu près ». HomeBox est un outil libre, léger et auto-hébergé qui sert précisément à remplacer ce « à peu près » par un inventaire précis, avec photos, factures et notices.

À quoi sert HomeBox ?

HomeBox est un système d’inventaire et d’organisation pensé pour les particuliers. C’est la suite du projet HomeBox d’origine, aujourd’hui maintenue par SysAdmins Media sous licence AGPL v3. Il est écrit en Go, utilise SQLite et embarque son interface web : un seul conteneur suffit, sans base de données externe à administrer.

Ses usages typiques :

• Justifier un sinistre auprès de l’assurance : liste des biens, photos, prix et dates d’achat, numéros de série, factures et garanties au même endroit.
• Savoir où sont les choses : chaque objet est rattaché à un emplacement (pièce, meuble, étagère, boîte), ce qui évite le « on en a déjà un quelque part ».
• Suivre garanties et entretien : dates d’achat, fin de garantie, échéances de maintenance.
• Conserver la documentation : notices, éclatés, catalogues, manuels, joints directement à la fiche de l’objet.
• Gérer un atelier ou une collection : outillage, machines, composants, avec des champs personnalisés (référence, marque, état, etc.).

Ce qu’il fait concrètement

• Organisation par emplacements (hiérarchiques), étiquettes et champs personnalisés.
• Recherche rapide dans tout l’inventaire.
• Photos et pièces jointes (documents, garanties, factures).
• Informations d’achat : date, prix, vendeur, durée de garantie.
• Import et export CSV : on peut partir d’un tableur existant et ressortir ses données à tout moment.
• Génération d’étiquettes avec QR code à coller sur les boîtes et les rangements.
• Interface utilisable sur ordinateur, tablette et téléphone.
• API REST, point de contrôle de santé (utile pour la supervision) et client MQTT pour les intégrations domotiques.

Pourquoi l’auto-héberger ?

Un inventaire pour l’assurance contient la liste de tout ce qui a de la valeur chez vous, avec photos. C’est typiquement une donnée que l’on préfère garder chez soi plutôt que sur un service tiers. Il n’y a ni abonnement, ni limite d’objets, ni suivi. Contrepartie : la sauvegarde devient votre responsabilité, et il faut qu’elle soit hors de la maison, sinon un incendie emporte l’inventaire avec le reste (voir la section sauvegarde).

Lire la suite…

Summary – or why should I monitor the filesystem at all?

The need to scan a given filesystem for changes is a fairly common one, and there are a variety of common tasks which require this, including:

• Notifying applications of changes in configuration files
• Tracking changes in critical system files
• Monitoring overall disk usage on a partition
• Automatic cleanup after a crash
• Automatic triggering of backup processes
• Sending notifications when the upload of a file to a server completes

A common approach to doing this sort of change notification is file polling, however this tends to be inefficient for all but the most frequently-changed files (since you have a guaranteed I/O every X seconds) and can miss certain types of changes (e.g. if the modification timestamp on a file isn’t changed). Data integrity systems like Tripwire track file changes based on a fixed time schedule, but the time-scheduled approach doesn’t work if you want to be notified every time it changes in real-time – just as an event takes place. A framework which fulfills that requirement is Inotify. In this article we will walk through how to use Inotify to monitor directories and trigger alerts on changes and present tools you might want to add to your personal toolbox.

Lire la suite…

By default any modern Linux distributions will have IP Forwarding disabled. This is normally a good idea, as most peoples will not need IP Forwarding, but if we are setting up a Linux router/gateway or maybe a VPN server (pptp or ipsec) or just a plain dial-in server then we will need to enable forwarding. This can be done in several ways that I will present bellow.

Check if IP Forwarding is enabled

We have to query the sysctl kernel value net.ipv4.ip_forward to see if forwarding is enabled or not: Using sysctl:

sysctl net.ipv4.ip_forward
net.ipv4.ip_forward = 0

or just checking out the value in the /proc system:

cat /proc/sys/net/ipv4/ip_forward
0

As we can see in both the above examples this was disabled (as show by the value 0).

Enable IP Forwarding on the fly

As with any sysctl kernel parameters we can change the value of net.ipv4.ip_forward on the fly (without rebooting the system):

sysctl -w net.ipv4.ip_forward=1

or

echo 1 > /proc/sys/net/ipv4/ip_forward

the setting is changed instantly; the result will not be preserved after rebooting the system.

Permanent setting using /etc/sysctl.conf

If we want to make this configuration permanent the best way to do it is using the file /etc/sysctl.conf where we can add a line containing net.ipv4.ip_forward = 1

/etc/sysctl.conf:
net.ipv4.ip_forward = 1

if you already have an entry net.ipv4.ip_forward with the value 0 you can change that 1.

To enable the changes made in sysctl.conf you will need to run the command:

sysctl -p /etc/sysctl.conf

On RedHat based systems this is also enabled when restarting the network service:

service network restart

and on Debian/Ubuntu systems this can be also done restarting the procps service:

/etc/init.d/procps.sh restart

Using distribution specific init scripts

Although the methods presented above should work just fine and you would not need any other method of doing this, I just wanted to note that there are also other methods to enable IP Forwarding specific to some Linux distributions. For example Debian based distributions might use the setting:

/etc/network/options:
ip_forward=no

set it to yes and restart the network service. Also RedHat distributions might set this using:

/etc/sysconfig/network:
FORWARD_IPV4=true

and again restart the network service.

Regardless the method you have used once you have completed this you can check it out using the same method shown above:

sysctl net.ipv4.ip_forward
net.ipv4.ip_forward = 1




cat /proc/sys/net/ipv4/ip_forward
1

If the result is 1 then the Linux system will start forwarding IP packets even if they are not destined to any of its own network interfaces.