J'ai encore changé mon setup serveurs à la maison... Je pense que dès qu'un truc tourne rond ça m'angoisse, me perturbe et m'incite à tout éclater pour recommencer 😦 🥳

Exit UNRAID, retour sur Debian server + Docker (et toujours dockge, ultra pratique !) \o/

J'en ai profité pour racheter un mini PC HP EliteDesk 705 G4, en Amazon refurbished, avec un Ryzen 5 Pro 2400ge, 16Go de RAM et NVMe+SSD. Sous Debian également, son job est de faire tourner ce blog, AdGuardHome, un proxy Nginx et un speedtest. Pour l'instant, il peut faire bien plus.

UNRAID tournait sur un HP ProDesk 400 G6 Desktop Mini PC embarquant un i5-10500T, 12Go de RAM et NVMe/SSD. C'est lui qui s'est pris un reset des familles (ou presque vu qu'UNRAID tourne sur une clé USB) et après ajout d'une Debian server, je commence à réinstaller du Plex/*arr + Usenet/BitTorrent. Je voulais lui ajouter un peu de stockage et je suis tombé sur un sympathique rack sur Amazon : ORICO Station d'Accueil 5 Baies pour Disques Durs avec Fonction de Clonage Hors Ligne

Pour 130€, c'est un dock avec 5 slots SATA, en USB et alimentation externe. Évidemment, vu l'USB, faut pas s'emballer et utiliser ça pour du gaming. Mais pour stocker des documents, seeder en BitTorrent ou streamer une vidéo c'est parfait !

Il y a un petit bouton aux fesses pour activer le mode PC ou clonage. J'ai pas testé mais il semble que ce soit tout à fait au point :)

En PC les disques sont reconnus tout de suite sur Windows comme Linux, je les ai montés dans /mnt/DataExt et Films, Series etc.

aerya@HomeBox:~$ df -H
Sys. de fichiers Taille Utilisé Dispo Uti% Monté sur
udev               8,3G       0  8,3G   0% /dev
tmpfs              1,7G    1,1M  1,7G   1% /run
/dev/nvme0n1p2     250G    2,3G  235G   1% /
tmpfs              8,3G       0  8,3G   0% /dev/shm
tmpfs              5,3M       0  5,3M   0% /run/lock
/dev/nvme0n1p1     536M    6,2M  530M   2% /boot/efi
tmpfs              1,7G       0  1,7G   0% /run/user/1000
tmpfs              1,7G       0  1,7G   0% /run/user/0
/dev/sda1          472G     29k  448G   1% /mnt/DataInt
/dev/sdb1          8,0T     29k  7,6T   1% /mnt/DataExt
/dev/sdc1          2,0T     29k  1,9T   1% /mnt/Films
/dev/sdd1          2,0T     29k  1,9T   1% /mnt/Series
/dev/sde1          2,0T     29k  1,9T   1% /mnt/Stuff
/dev/sdf1          2,0T     29k  1,9T   1% /mnt/Comics

Mon serveur embarque UNRAID qui gère les Dockers via un panel bien fait mais qui implique qu'ils soient au préalable disponibles dans leur "store" d'applications.
C'est un peu limitant quand ce qu'on souhaite n'y est pas et, surtout, qu'on vient de Linux où tout peut se lancer en CLI par exemple.

UNRAID permet d'installer un plugin docker-compose qui ajoute cette fonctionnalité en bas de l'onglet Docker mais c'est pas le plus ergonomique.

Dockge, créé par louislam, s'installe évidemment en Docker et permet de gérer tous les compose.yml simplement depuis une interface dédiée

Plus simple, plus pratique. Et ça s'installe partout où on veut 😄

I'm back !

J'ai pu récupérer 90% de mes articles, y'a un paquet de mise en page à refaire (un jour...) et j'ai perdu ceux depuis mars 2022. Certains m'ont contactés en m'indiquant qu'ils avaient des archives via RSS, si vous avez les images ça peut servir en effet :)
Si vous voulez commenter les articles il faut vous inscrire sur le blog (je me moque des IP et emails, j'en ferai rien) sinon il y a toujours Discord.

Le stockage sur Telegram via TelDrive et rClone

Le stockage "illimité" à pas cher chez Amazon, Google et Dropbox : c'est terminé ! On en a abusé et bien profité. Il reste Opendrive, chez qui j'ai eu un compte, qui permet de stocker de manière illimité mais ils limitent la vitesse d'upload (et non d'accès) passés les 15To environ. Ceci dit, pour 10€/mois, ça en fait un bon endroit pour stocker quelques documents chiffrés via rClone (montez ça en WebDav, c'est le plus stable).

Depuis quelques mois divyam234 joue avec le stockage de Telegram et il a modifié une version de rClone pour l'intégrer dans les remotes :

• On profite du chiffrement de Telegram,
• DL/UP via des bots Telegram, chacun étant limité en actions et vitesse d'upload (5Mo/s sauf erreur), il est recommandé d'en utiliser au moins 4 parallèlement,
• Utilisable via rClone (montage, upload, cache),
• Le stockage est illimité et lié à votre compte Telegram.

Les risques : avec l'abus qui se profile TelDrive et/ou rClone risquent d'être bannis, à trop stocker vous risquez d'être banni.

aerya@ubuntulab:~$ df -H
Filesystem         Size  Used Avail Use% Mounted on
tmpfs              206M  1,2M  205M   1% /run
/dev/vda2           52G  5,8G   44G  12% /
tmpfs              1,1G     0  1,1G   0% /dev/shm
tmpfs              5,3M     0  5,3M   0% /run/lock
/dev/vda1          1,2G  6,4M  1,2G   1% /boot/efi
UNRAID              17T  4,1T   13T  24% /mnt/UNRAID
tmpfs              206M  4,1k  206M   1% /run/user/1000
TelDrive1Crypted:  1,2P     0  1,2P   0% /mnt/TelDrive1Crypt

Passons aux choses sérieuses :
- Un environnement Linux,
- Un compte Telegram (que vous pouvez potentiellement perdre => une eSIM Free à 2€ est parfaite), un canal et des bots,
- Créer une app Telegram et en récupérer les ID/Hash,
- Une base de données Postgres (à auto-héberger en Docker par exemple),
- TelDrive de divyam234 qui est un outil d'accès au stockage Telegram avec WebUI,
- Sa version modifiée de rClone,
- Suivre mon tutoriel \o/

Pour créer un canal sur Telegram il faut cliquer sur l'icône en haut à droite de l'application, sorte de carré avec un stylo, puis Nouveau canal, le nommer et je pense qu'il convient de le laisser en Privé pour ce type d’utilisation.

Ensuite on crée une application, gratuite évidemment, qui permettra de récupérer des identifiants à utiliser pour TelDrive. Se rendre sur https://my.telegram.org/auth, renseigner son numéro et y accéder via le code unique reçu sur Telegram.
Aller ensuite sur https://my.telegram.org/apps et en créer une "bidon". Le but étant d'obtenir l'ID et le Hash.

TelDrive nécessite une base de données PostgreSQL L'auteur recommande de se servir de NeonTech en version gratuite, je ne suis pas à un Docker près et préfère héberger ça.

docker run -d \
  --name='postgresql' \
  --net='bridge' \
  -e TZ="Europe/Paris" \
  -e 'POSTGRES_PASSWORD'='<pwd>' \
  -e 'POSTGRES_USER'='<user>' \
  -e 'POSTGRES_DB'='teldrivetesting' \
  -p '5432:5432/tcp' \
  -v '/mnt/user/newappdata/postgresql':'/var/lib/postgresql/data':'rw' 'postgres:16' \

On continue avec TelDrive. Voici mon exemple en Docker. J'utilise toujours en partie Watchtower, si ce n'est pas votre cas retirez la partie "labels". Les variables sont à remplir/ajouter selon les besoins :

• APP_ID et APP_HASH sur les informations obtenues en créant l'application Telegram
• JWT_SECRET est un token d'accès à votre compte Telegram. Il recommande d'en créer un unique et aléatoire via une génération openssl : openssl rand -hex 32
• DATABASE_URL reprend les infos remplies précédemment avec le Docker Postgre
• COOKIE_SAME_SITE ne semble pas être nécessaire, j'ai pas testé sans
• LAZY_STREAM_BOT (qu'il vient de passer en false par défaut ce soir) pour que les bots ne se lancent qu'en cas d'utilisation

services:
  server:
    image: ghcr.io/divyam234/teldrive/server
    restart: always
    container_name: teldrive
    volumes:
      - /mnt/user/newappdata/teldrive/teldrive.db:/app/teldrive.db:rw
    environment:
      APP_ID: ***
      APP_HASH: ***
      JWT_SECRET: ***
      DATABASE_URL: postgres://<user>:<pwd>@10.0.4.64:5432/teldrivetesting
      COOKIE_SAME_SITE: true
      LAZY_STREAM_BOTS: true
    ports:
      - 3120:8080
    labels:
      - "com.centurylinklabs.watchtower.enable=true"

La WebUI est servie sur le port 3120 et on s'y connecte avec notre compte Telegram

Commencer par aller dans les options et sélectionner le canal Telegram pour le stockage des fichiers

Puis ajouter des bots. Ces derniers serviront pour UP/DL via TelDrive, donc rClone. Pour ça aller sur Telegram, contacter BotFather (@BotFather) et créer les bots 1 par 1 avec la commande /newbot puis copier 1 par 1 les token des bots dans cet encart (oui, c'est ch*ant).

Et pour terminer, mettre autant d'uploads simultanés que de bots créés

Voici venu le temps des rires et des chants d'installer rClone, en version modifiée bien entendu.
J'ai testé sur Ubuntu (faut que je regarde sur UNRAID si je peux en installer 2 en parallèle), j'ai pas compilé mais installé directement le .deb

wget https://github.com/divyam234/rclone/releases/download/v1.64.3/rclone-v1.64.3-linux-amd64.deb
sudo dpkg -i rclone-v1.64.3-linux-amd64.deb

Il nous faudra une session (cookie) TelDrive pour créer le remote. Pour l'obtenir, se rendre sur la WebUI, F12 (sous Firefox) et onglet Storage puis cookie et récupérercelui de TelDrive. Ce sera l'access token pour configurer rClone (je passe les détails, ça doit faire 7-8 ans que je l'explique) avec un remote TelDrive (numéro 47).

Par habitude j'ai ensuite créer un remote chiffré mais c'est inutile vu que Telegram est par défaut chiffré...

Au final le fichier de configuration rClone ressemble à ceci :

[TelDrive1]
type = teldrive
access_token = eyJh[...]00g
api_host = http://10.0.4.64:3120
chunk_size = 1Gi

[TelDrive1Crypted]
type = crypt
remote = TelDrive1:
password = ***

De là on peut repartir comme en 40 avec nos scripts de montage et d'upload, comme pour Google, Dropbox etc
Gardez tout de même en tête que comme pour les ex-eldorados du stockage "illimités" à prix cassés, à force d'abus des uns et des autres, cette astuce finira par disparaître.

Exemple de montage

rclone mount TelDrive1: /mnt/TelDrive1 \
--allow-other \
--allow-non-empty \
--dir-cache-time 24h \
--log-level INFO \
--log-file /home/aerya/TelDrive1Mount.log \
--poll-interval 10s \
--umask 002 \
--user-agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.113 Safari/537.36" \
--drive-pacer-min-sleep 10ms \
--drive-pacer-burst 200 \
--vfs-read-ahead 2G \
--tpslimit 12 \
--tpslimit-burst 12

root@ubuntulab:/home/aerya# df -H
Filesystem         Size  Used Avail Use% Mounted on
tmpfs              206M  1,2M  205M   1% /run
/dev/vda2           52G  5,9G   43G  12% /
tmpfs              1,1G     0  1,1G   0% /dev/shm
tmpfs              5,3M     0  5,3M   0% /run/lock
/dev/vda1          1,2G  6,4M  1,2G   1% /boot/efi
UNRAID              17T  4,1T   13T  24% /mnt/UNRAID
tmpfs              206M  4,1k  206M   1% /run/user/1000
TelDrive1Crypted:  1,2P     0  1,2P   0% /mnt/TelDrive1Crypt

Exemple d'upload d'un fichier de 10Go (fallocate -l 10G film.mkv) avec 4 bots => 4x5Mo/s de moyenne

rclone move -c -v --copy-links --user-agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.113 Safari/537.36" --fast-list --drive-stop-on-upload-limit --transfers=10 --checkers=10 --stats 5s /mnt/PRE TelDrive1:/

2023/11/08 22:14:51 INFO  : Films/film.mkv: Multi-thread Copied (new)
2023/11/08 22:14:51 INFO  : Films/film.mkv: Deleted
2023/11/08 22:14:51 INFO  :
Transferred:   	       10 GiB / 10 GiB, 100%, 17.132 MiB/s, ETA 0s
Checks:                 2 / 2, 100%
Deleted:                1 (files), 0 (dirs)
Renamed:                1
Transferred:            1 / 1, 100%
Elapsed time:     10m18.0s

Hier soir j'ai testé avec une vraie vidéo de 16Go, lue ensuite avec VLC via le montage sur Linux : nickel :)

Enjoy ! (pour la Science seulement !)

Hello,

J'ai pas mieux comme sauvegarde... Plus d'1 an d'articles perdus mais c'est mieux que rien. De toute manière j'avais surtout publié sur rClone et Google et cette solution de stockage en ligne est maintenant obsolète.

J'ai un vieux backup .xml de l'époque où j'avais transféré Wordpress vers Ghost, je tenterai de l'ajouter.

A.

Petit mémo du matin : installer les drivers EPSON sur Linux

sudo apt install printer-driver-escpr

Et ensuite il suffit de chercher & sélectionner son modèle.

Entre boulot par-dessus la tête et galères perso, j'ai enfin réussi à monter (en partie) mon UltiMox !! :)

Tout tournait rond. Je suis geek. Fallait que je change.

Serveur Proxmox/Docker/rClone au garage à base de i3-8100, 24GB de RAM (qu'il fallait que j'augmente). PC de jeu sous Windows 10, i7-8700K, 32BG de RAM, nVidia RTX 2070.

J'ai eu envie de m'enquiquiner me faire une seule machine qui me permettrait de profiter pleinement de l'ensemble de mon matériel. Pour ça, de mon point de vue, rien de mieux que d'allier Proxmox à un environnement de bureau, Plasma (sudo apt install task-kde-desktop), avec la simplicité de Docker, la capacité de rClone et la puissance d'une RTX en passthrough sur une VM Windows dédiée au jeu vidéo. Il faut évidemment une autre carte graphique ou un processeur avec iGPU, ce qui est mon cas (puisque du coup la RTX ne sera plus utilisable sur l'hôte).

J'ai commencé mes tests la semaine passée et le passthrough RTX n'était pas terrible. J'y suis retourné lundi et SuperBoki m'a fait découvrir Parsec qui m'a permis de me connecter de manière très fluide à une VM Windows. Assez fluide pour jouer correctement à R6S à 190 FPS, pas encore ce j'avais sur un Windows natif mais je m'en approche (240 FPS).

Je me suis donc lancé dans l'aventure lundi après-midi et pensais n'en avoir que pour 24h.

C'était sans compter le boulot urgent qui m'est tombé dessus mardi (je pleure pas, j'ai besoin de gagner ma vie mais pourquoi ce jour-là ?!) et ma poisse : le i7 et sa carte-mère sont HS (ça n'aime pas la bière... j'étais crevé mardi soir), ça tourne donc avec le i3 qui m'interdit la VM de jeu sous Windows (faut que je prenne un i9-9900k vu ma CM en LGA1151), il me manque de la connectique SATA pour mon alimentation modulaire 750W Xilence (ça arrive demain, je ne peux brancher que 9 disques sur 17), mon dissipateur thermique BeQuiet est trop large pour cette CM (MSI Z390 Gaming Plus) et m'empêche de mettre mes 4 barrettes de RAM...

Zen, restons zen...

Y'a quand même du bon : j'ai pu ajouter des ventilateurs BeQuiet, la tour en compte donc 6. A voir cette été s'il refait 40°+.

Petit bémol aussi avec Plasma, Network Manager ne détecte aucun réseau. On ne peut donc pas utiliser le magasin d'applications Discover (mais on a bien Internet, les mails, KDE Connect etc). Ce qui n'empêche pas d'installer de qu'on veut sur Linux... Je verrai plus tard si ça peut se corriger d'autant que NM fonctionne très bien sous XFCE.

Je ne m'inquiète pas pour ma VM Windows, elle fonctionnera :) Je verrai ça quand j'aurais changé de CPU et vu le prix je suis un peu frileux pour l'instant. J'ai encore le laptop Alienware pour dépanner même si son dual GTX560M prend de l'âge.

Me reste donc à rebrancher l'ensemble de mes disques, à refaire du RAID, réinstaller les montages/scripts rClone et tout ce qui va avec point de vue torrenting. Usenet étant déporté avec les *arr sur un NUC.

Ah si, j'oubliais. Le VPN.

On peut installer un client VPN comme sur n'importe quel OS Linux. Le hic dans ce contexte précis c'est que du coup l'ensemble du trafic passera par le VPN. Ce que je ne veux pas.
Je me sers donc d'un client VPN en Docker, avec proxy, pour passer sous VPN des applications (en dur ou Docker) et des navigateurs.

Cette nuit mon NUC Archlinux a rendu l'âme :'(

Avant le backup de 4h, sinon c'est pas marrant. Heureusement le SSD n'a rien et je peux le remonter/déchiffrer et en récupérer le contenu.

Je profite de cette "occasion" pour passer mon Archlinux de tous les jours dans le Cloud. En l'occurrence sur une VM Proxmox avec l'ISO de Manjaro Archlinux (version XFCE dans mon cas), hébergé dans mon garage, avec un accès via NoMachine. Avant j'avais accès à des documents via le Cloud, maintenant j'aurai carrément mon Bureau complet :)   #hommemoderne #geekmoderne

J'ai donc accès à mon Bureau Manjaro depuis le PC de jeu sous Windows ou mes laptops. Voire même de n'importe quelle machine sur laquelle je peux installer NoMachine.

Merci à zealot001 qui m'a filé un script plus propre que le mien :P

Voici de quoi synchroniser des Team Drives et des clés d'accès Service Accounts (tutoriel).

#!/bin/bash

OPTIONS="-c -P --transfers 3 --checkers 3 --size-only --drive-server-side-across-configs --drive-stop-on-upload-limit"
SAKEYS="/home/aerya/scripts/rclone/sakeys"
LOG="/home/aerya/logs/rclone.log"
R1="FreeTD1"
R2="FreeTD2"
R3="FreeTD3"
R4="FreeTD4"


[[ "$(pidof -x $(basename $0))" != $$ ]] && echo "[KO] Script déja en cours" && exit 1

sync_rlcone()
{
    echo -e "$(date +"%Y-%m-%d %H:%M:%S") : Start rClone sync "$1"" >> "$LOG"
    rclone sync "$2": "$1": "$OPTIONS" --drive-service-account-file="$SAKEYS"/"$1".json
    if [[ $? -eq 0 ]] ; then
        echo -e "$(date +"%Y-%m-%d %H:%M:%S") : rClone sync "$1" OK\n" >> $LOG
    else
        echo -e "$(date +"%Y-%m-%d %H:%M:%S") : rClone sync "$1" ERROR\n" >> $LOG
    fi
}

sync_rlcone "$R2" "$R1"
sync_rlcone "$R3" "$R2"
sync_rlcone "$R4" "$R3"

J'ai placé ça en CRON toutes les 4h et ça fait le café

# rClone Sync
0 */4 * * * /home/aerya/scripts/rclone/sync.sh

Avec les notifications Discord (tutoriel)

stockage
BOT
 — Aujourd’hui à 16:00
FreeTD1  ==> Total size: 6.128 TiB (6737761093015 Byte)
FreeTD2  ==> Total size: 6.128 TiB (6737761093015 Byte)
FreeTD3  ==> Total size: 6.128 TiB (6737761093015 Byte)
FreeTD4  ==> Total size: 6.128 TiB (6737761093015 Byte)

Explications des variables, à adapter à votre configuration

OPTIONS="-c -P --transfers 3 --checkers 3 --size-only --drive-server-side-across-configs --drive-stop-on-upload-limit"
options de rClone, le --drive-server-side-across-configs servant à tout faire passer chez Google plutôt que par mon serveur (quelques GB/s de vitesse de transfert du coup)

SAKEYS="/home/aerya/scripts/rclone/sakeys"
dossier des clés SA. 1 clé par TD, chacune étant nommée comme lui => FreeTD1 = FreeTD1.json etc

[root@pve rclone]$ ls -l /home/aerya/scripts/rclone/sakeys
total 55
-rwxrwxrwx 1 root root 2333 Dec 28 11:00 FreeTD1.json
-rwxrwxrwx 1 root root 2333 Dec 28 11:00 FreeTD2.json
-rwxrwxrwx 1 root root 2333 Dec 28 11:00 FreeTD3.json
-rwxrwxrwx 1 root root 2333 Dec 28 11:00 FreeTD4.json

LOG="/home/aerya/logs/rclone.log"
les logs de rClone, ça ressort sous cette forme

2022-02-15 16:00:02 : Start Rclone sync FreeTD2
2022-02-15 16:01:57 : Rclone sync FreeTD2 OK
2022-02-15 16:01:57 : Start Rclone sync FreeTD3
2022-02-15 16:03:43 : Rclone sync FreeTD3 OK
2022-02-15 16:03:43 : Start Rclone sync FreeTD4
2022-02-15 16:05:24 : Rclone sync FreeTD4 OK

R1="FreeTD1" R2="FreeTD2" R3="FreeTD3" R4="FreeTD4"
les remotes rClone non déchiffrés, le 1 étant copié sur le 2, le 2 sur le 3, le 3 sur le 4. Pourquoi les remotes non déchiffrés ? Pour copier les données chiffrés du 1er team drive sur tous les autres et donc utiliser le même chiffrement partout.

Regardons le rclone.conf

[root@pve rclone]$ cat /root/.config/rclone/rclone.conf
[FreeTD1]
type = drive
client_id = xxx
client_secret = Gxxx
scope = drive
token = xxx
team_drive = ABC
root_folder_id =

[FreeTD1Crypt]
type = crypt
remote = FreeTD1:
password = motdepassesuperdur

[FreeTD2]
type = drive
client_id = xxx
client_secret = xxx
scope = drive
token = xxx
team_drive = DEF
root_folder_id =

[FreeTD3]
type = drive
client_id = xxx
client_secret = xxx
scope = drive
token = xxx
team_drive = GHI
root_folder_id =

[FreeTD4]
type = drive
client_id = xxx
client_secret = xxx
scope = drive
token = xxx
team_drive = JKL
root_folder_id =

Je n'ai besoin que d'un remote déchiffré (FreeTD1Crypt:). Comme le contenu chiffré du Team Drive FreeTD1: est synchronisé sur les autres TDs, si le TD1 venait à "disparaître", je n'aurais qu'à ajouter à la main dans mon rclone.conf un remote déchiffré pour le FreeTD2: pour m'en servir.

[FreeTD2Crypt]
type = crypt
remote = FreeTD2:
password = motdepassesuperdur

Bien entendu le script est adaptable pour des GDrives ou GD/TD mélangés. Ici les accès aux TDs 2, 3 et 4 se font via les clés SA qui y sont liées mais on pourrait aussi faire sans clé et uniquement avec l'accès GDrive classique.

Comme beaucoup d'entre-nous, j'ai (eu) des boîtes en plastiques, des trieurs, des pochettes pour les fiches de paies, déclarations d'imposition, factures réglées, diplômes, bilans de santé et dossiers d'hospitalisation etc.

J'ai malheureusement vu dans mon entourage les désastres provoqués par des incendies ou cambriolages et la perte de certains documents. J'ai donc pris pour habitude il y a des années de scanner tous les documents papiers "importants" que je recevais et de les archiver dans des dossiers éponymes. Dossiers ensuite sauvegardés localement et sur le Cloud, après chiffrement.

Mais ça fait aussi quelques temps que je songe à optimiser tout ça, immédiatement suivi du fameux "Un jour" :)
Paperless, et maintenant Paperless-ng, rendent justement toute cette numérisation plus simple.

TL ; DR: ce truc est tout simplement top !

D'avantage de screens dans la documentation.

Le principe est simple : on l'alimente (FTP, upload, email, client mobile) avec des documents (images, PDF, MSOffice, LibreOffice, .txt, scans...) et il aide à les trier (OCR, tags...), les archiver et les rend accessible via mots clés/catégories/date/whatever, en format PDF notamment.

Bien évidemment ça suppose de pouvoir scanner des documents (Cap'tain Obvious!). Du coup on voit vite si on a l'équipement requis, à savoir un modèle précis (parce que testé) de scanner ou une application Android/iOS. Notez que pour Android il y a également (et je me sers de) PaperlessApp & PaperlessShare.

Il n'intègre pas de solution de chiffrement. La logique étant qu'on stocke en général nos documents personnels dans un endroit relativement sécurisé (si vous venez de Windows, ne vous posez pas trop de questions ^^') et que chacun a sa solution de sauvegarde (3-2-1 de préférence, là on ne parle de films de vacances) qui inclut du chiffrement.

Pour simplifier l'installation ils proposent notamment plusieurs compose (Docker donc). Je privilégie la version "Tika & PostgreSQL".
Apache Tika permet d'extraire les métadonnées des documents Office notamment et je pense que Postgre sera plus performant que SQLite dans ce contexte de traitement de gros volumes de données.

J'adapte les fichiers pour ma configuration

.env

COMPOSE_PROJECT_NAME=paperless

docker-compose.env : clé secrète + TZ + français

USERMAP_UID=1000
USERMAP_GID=1000

PAPERLESS_SECRET_KEY=mgp5pwptQo7WIfVBU8BsHyMGXk1LVSN2uNcpX1I1wnNYHDS4kDHFrwRHR5XS3DBEA

PAPERLESS_TIME_ZONE=Europe/Paris

PAPERLESS_OCR_LANGUAGE=fra

Au niveau des dossiers à monter :

/var/lib/postgresql/data = données SQL
/usr/src/paperless/data = données générales (config)
/usr/src/paperless/media = documents traités (archivés)
/usr/src/paperless/consume = dossier de réception des documents à traiter

Attention, pour pouvoir assimiler des fichiers *Office, il faut des versions précises de Gotenberg et Tika (j'ai testé en vain toutes les autres).

docker-compose.yml

version: "3.4"
services:
  broker:
    image: redis:6.0
    container_name : paperlessredis
    restart: always

  db:
    image: postgres:13
    container_name : paperlesspostgres
    restart: always
    volumes:
      - /home/aerya/docker/paperless/sql:/var/lib/postgresql/data
    environment:
      POSTGRES_DB: xxx
      POSTGRES_USER: xxx
      POSTGRES_PASSWORD: xxx

  webserver:
    image: jonaswinkler/paperless-ng:latest
    container_name : paperless
    restart: always
    depends_on:
      - db
      - broker
      - gotenberg
      - tika
    ports:
      - 8024:8000
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8024"]
      interval: 30s
      timeout: 10s
      retries: 5
    volumes:
      - /home/aerya/docker/paperless/data:/usr/src/paperless/data
      - /Data/paperless/media:/usr/src/paperless/media
      - /Data/paperless/consume:/usr/src/paperless/consume
    env_file: docker-compose.env
    environment:
      PAPERLESS_REDIS: redis://broker:6379
      PAPERLESS_DBHOST: db
      PAPERLESS_TIKA_ENABLED: 1
      PAPERLESS_TIKA_GOTENBERG_ENDPOINT: http://gotenberg:3000
      PAPERLESS_TIKA_ENDPOINT: http://tika:9998
    labels:
      - com.centurylinklabs.watchtower.enable=true

  gotenberg:
    image: thecodingmachine/gotenberg:6
    container_name : paperlessgotenberg
    restart: always
    environment:
      DISABLE_GOOGLE_CHROME: 1
      DEFAULT_WAIT_TIMEOUT: 30

  tika:
    image: apache/tika:1.27
    container_name : paperlesstika
    restart: always

Et me contente de suivre les instructions

[root@pve docker]$ mkdir paperless
[root@pve docker]$ cd paperless/
[root@pve paperless]$ nano .env
[root@pve paperless]$ nano docker-compose.env
[root@pve paperless]$ nano docker-compose.yml
[root@pve paperless]$ nano docker-compose.yml

[root@pve paperless]$ docker-compose pull
[...]

[root@pve paperless]$ docker-compose run --rm webserver createsuperuser
Creating paperlessredis     ... done
Creating paperlessgotenberg ... done
Creating paperlesspostgres  ... done
Creating paperlesstika      ... done
Paperless-ng docker container starting...
Creating directory /tmp/paperless
Adjusting permissions of paperless files. This may take a while.
Waiting for PostgreSQL to start...
Apply database migrations...
Operations to perform:
  Apply all migrations: admin, auth, authtoken, contenttypes, django_q, documents, paperless_mail, sessions
Running migrations:
  Applying contenttypes.0001_initial... OK
  Applying auth.0001_initial... OK
  Applying admin.0001_initial... OK
[...]
  Applying paperless_mail.0008_auto_20210516_0940... OK
  Applying sessions.0001_initial... OK
Executing management command createsuperuser
Username (leave blank to use 'paperless'): aerya
Email address: blog@upandclear.org
Password:
Password (again):
Superuser created successfully.

[root@pve paperless]$ docker-compose up -d
paperlessredis is up-to-date
paperlesspostgres is up-to-date
paperlessgotenberg is up-to-date
paperlesstika is up-to-date
Creating paperless ... done

Bien entendu y'aura un reverse-proxy d'ajouté pour faire propre :)

Je vais pas détailler tout le fonctionnement, déjà parce que la doc le fera mieux que moi, ensuite parce que je le découvre aussi. Niveau documentation justement, voici des liens importants : les différentes solutions d'ajout de document, comprendre les termes (Correspondant, Tags etc), comprendre la recherche.

Je vais par exemple ajouter une facture depuis le navigateur

Sur ce 1er onglet on peut voir/modifier/ajouter/créer diverses informations liées au document. Je vais par exemple faire comme si c'était une facture émise par ma société pour le client M. ACHETEUR.

Paperless-ng "apprend" et gagne en autonomie. Quand j'ajoute mon client M. ACHETEUR comme Correspondant, j'indique à Paperless-ng comment repérer et attribuer ce correspondant au futurs ajouts de documents le concernant

Tout comme j'ajoute également Mon Entreprise

J'ai donc les 2 correspondants. Si j'avais une SARL je pourrais aussi ajouter le comptable par exemple.

Même principe pour le Type de document

Et les étiquettes (tags)

On retrouve tout (ou on peut le créer dans) le panneau d'administration

Le contenu est OCRisé et pourra aussi être recherché (enfin je crois)

Et voilà, j'ai mon 1er document d'archivé :)

Faut pas se mentir, comme à chaque "1ère fois" ça va me prendre du temps d'ajouter tous nos documents et de créer les tags et autres afférents. Mais ensuite ajouter les documents au fil de l'eau, souvent de manière automatique (email + tags/correspondant auto) sera bien moins chronophage !

Dans leurs docker-compose ils ajoutent le dossier /export dans les montages. Celui-ci sert à exporter tout le contenu de Paperless-ng (données, configs, docs) en vue d'une sauvegarde ou d'une migration. Utilisant Docker ce n'est pas utile. Mon dossier /home/aerya/docker est déjà sous dans un cycle de backup et il ne manque que /Data/paperless, que j'ajoute.

J'ai testé avec des fichiers Excel et Classeur, ils sont bien reconnus et transformés en PDF.

Gratuit, open-source, auto-hébergeable (sic!), clients desktop Windows/MacOS/Linux, clients Android/iOS, émulation Web (le client Linux dans une page Web), c'est plutôt joli. Bref, j'ai toujours eu la flemme d'y passer, c'est fait.

Joplin, dont le nom ne vient de Janis mais d'un pianiste, est une application de création/partage de notes, documents et to-dos notamment en markdown. On peut travailler à plusieurs sur le même documents et supporte le E2E (chiffrement de bout en bout).

La synchronisation entre les différents clients peut se faire via leur offre Cloud ou en hébergeant soi-même le serveur ou encore via des systèmes classiques tels que Nextcloud, Webdav, OneDrive, S3, Dropbox...

Voici les liens à connaître/visiter :
- Le site de Joplin,
- Github,
- Les plugins, que j'ai pas encore pris le temps d'explorer en détail
- L'aide,
- Projet annexe de "Web-Viewer" qui s'installe en dur sur Linux (non testé)
- Ce que j'appelle l'émulation Web : un Docker qui héberge le client desktop Linux avec VNC (et ça reste léger)

Installation via Docker

version: '3'

services:
    db:
        image: postgres:13
        container_name : joplinpostgres
        volumes:
            - /home/aerya/docker/joplin/postgres:/var/lib/postgresql/data
        ports:
            - "5432:5432"
        restart: always
        environment:
            - POSTGRES_PASSWORD=xxx
            - POSTGRES_USER=xxx
            - POSTGRES_DB=xxx
    app:
        image: joplin/server:latest
        container_name : joplin
        depends_on:
            - db
        ports:
            - "22300:22300"
        restart: always
        environment:
            - APP_PORT=22300
            - APP_BASE_URL=https://notes.upandclear.org
            - DB_CLIENT=pg
            - POSTGRES_PASSWORD=xxx
            - POSTGRES_DATABASE=xxx
            - POSTGRES_USER=xxx
            - POSTGRES_PORT=5432
            - POSTGRES_HOST=db
        labels:
            - com.centurylinklabs.watchtower.enable=true

Il n'y a qu'un volume à monter, pour la base de données et attention à bien mettre l'APP_BASE_URL. Soit une URL soit sous la forme http:/IP:PORT (port 22300 par défaut).

Une fois le serveur installé, s'y connecter avec admin@localhost et admin en mot de passe. On est ensuite invité à changer le mot de passe et télécharger un client pour pouvoir utiliser Joplin.

Dans le client desktop, aller dans le menu Tools/Options pour le passer en VF notamment. Puis Synchronisation et sélectionner Joplin Server (BETA atm).

Sur mobile (Android du moins) le menu est en haut à gauche puis Configuration en bas.

J'ai pas encore fait le tour des plugins, j'y reviendrai si je découvre un truc hors du commun.

Quant à la version Web, comme je le mentionnais au début, elle doit s'installer en dur sur le serveur. Et je ne veux pas. Je lui préfère la pseudo version Web qui consiste en un Docker avec VNC et le client desktop Linux. C'est léger et propre.

J'en ai besoin pour me l'ajouter comme service dans Ferdi.

docker run -d \
--name=joplinwebvnc \
--restart always \
-p 5800:5800 \
-e VNC_PASSWORD=xxx \
-v /home/aerya/docker/joplin/webvnc:/app/.config \
--label=com.centurylinklabs.watchtower.enable=true \
acaranta/docker-joplin

On s'y connecte via IP:5800 (ou une URL, c'est plus sympa, faudra que j'y pense) et son mot de passe VNC

Pour des amis qui commencent à donner de l'argent à leurs ados j'ai cherché des solutions de suivi des dépenses. Vu leur âge ça va pas loin : kebab, ciné, quelques courses... Du basique.

C'est pas ce qui manque !
Oui, mais...

Qui soient respectueuses de la vie privée (donc plutôt auto-hébergées), puissent être partagées avec les parents, soient simples et compatibles Android et iOS.

Bref. Y'a plus 50 solutions finalement. Y'a peut-être mieux (plus simple je ne pense pas) mais j'ai jeté mon dévolu (et leur ai installé) sur SpendSpentSpent. C'est en anglais en plus, ça va faire bosser les mioches.

On l'installe en Docker

docker run -d \
--name=spent \
--restart always \
-v /home/aerya/docker/spent:/config \
-v /etc/localtime:/etc/localtime:ro \
-e SALT=1cb90a8eae77b64fb0c \
-p 9003:9001 \
-e ALLOW_SIGNUP=1 \
--label=com.centurylinklabs.watchtower.enable=true \
gonzague/spendspentspent

Pour le 1er lancement il faut ajouter -e ALLOW_SIGNUP=1 \. Une fois le compte Admin créé on peut recréer le Docker sans ce paramètre.

Pour le coup c'est vraiment basique mais c'est justement ce qui en fait son intérêt

La version Web est la version smartphone sur un écran plus grand. Je m'en sers pour les screens, ça m'est plus pratique.

On peut ajouter des catégories de dépenses et pour chacune des dépenses donc, agrémentées au besoin d'un emplacement GPS, d'une note voire d'une conversion de devises.

On peut également ajouter des dépenses récurrentes. Et on peut tout suivre par catégorie, jour, mois, année.

Pour les amateurs de téléchargement depuis des serveurs (sFTP, LFTP, RAR... certains reconnaîtrons), voici un outil qui peut remplacer quelques scripts lftp.

SeedSync est un outil avec WUI qui permet de télécharger automatiquement des fichiers sur un serveur donné selon des paterns. Et ça gère donc l'extraction des archives. Le nom peut prêter à confusion mais il s'agit bien d'une synchronisation à sens unique : distant => local. Pour du double-sens il y a notamment Syncthing.

Installation en Docker suivant la documentation

docker run -d \
--name=seedsync \
--restart always \
-p 8800:8800 \
-v /mnt:/downloads \
-v /home/aerya/docker/seedsync:/config \
--label=com.centurylinklabs.watchtower.enable=true \
ipsingh06/seedsync

On le configure rapidement avec une IP de serveur distant, son port SSH (ou sFTP, c'est la même) et un user:pwd. Puis le dossier à surveiller sur le serveur distant et celui où télécharger localement les fichiers.

La Dashboard liste alors l'ensemble des dossiers/fichiers et leur état de DL ou non.

Pour automatiser le DL on peut créer des paterns

On peut mettre en pause/reprendre.

Même sans accès Scene SeedSync est bien utile pour par exemple rapatrier chez soi des téléchargements effectués sur une seedboxe distante.

Amateur de FileRun (à voir comme une sorte de Gmail auto-hébergé), je n'ai pas encore réinstallé d'explorateur Web sur mon serveur DIY. L'occasion de tester Filebrowser et je dois dire que je ne suis pas déçu :
- Simple
- Gestion d'utilisateurs/droits
- Partage de fichiers.

Bien entendu il n'est pas aussi complet que Next/OwnCloud, Seafile, Pydio, FileRun etc mais il est amplement suffisant pour des besoins simples comme le mien : accéder aux fichiers de mon serveur et pouvoir en DL/uploader.

L'installation est bien entendu simplifiée par Docker.

Une fois qu'on sait où l'installer, y créer le fichier qui lui servira de base de données

[root@pve rclone]$ cd /home/aerya/docker/filebrowser/
[root@pve filebrowser]$ touch filebrowser.db

Puis créer le fichier de configuration suivant leur exemple. Comme je ne vais l'utiliser qu'ne local je ne modifie rien mais j'aurais pu ajouter une URL.

{
  "port": 80,
  "baseURL": "",
  "address": "",
  "log": "stdout",
  "database": "/database/filebrowser.db",
  "root": "/srv"
}

Et on lance le Docker

docker run -d \
--name=filebrowser \
--restart always \
-v /Data:/srv \
-v /home/aerya/docker/filebrowser/filebrowser.db:/database/filebrowser.db \
-v /home/aerya/docker/filebrowser/settings.json:/config/settings.json \
-e PUID=0 \
-e PGID=0 \
-p 3264:80 \
--label=com.centurylinklabs.watchtower.enable=true \
filebrowser/filebrowser:s6

Le login par défaut est admin:admin

On peut ensuite changer le mot de passe comme le nom du compte admin, le mettre en français et régler quelques options.

Pour simplifier l'accès à nos emails depuis n'importe quel PC/tablette dans la maison j'ai voulu me réinstaller un Webmail. Un simple, qui permette de grouper tous les comptes IMAP dans une seule boîte de réception. Et évidemment gratuit. Et aussi qui ne vienne pas avec un serveur de mails (mais WTF! Depuis quand un webmail a un truc à voir avec un serveur de mails). Et plutôt moderne niveau interface. Puis, tant qu'à faire, qui existe en version Docker.

En sus de l'incontournable RoundCube, j'avais déjà testé et utilisé Rainloop. J'en ai donc profité pour chercher et tester d'autres outils sur Github.

J'ai trouvé ma petite perle :)   Cypht !
Plusieurs années d’existence et toujours suivi, un développeur avec de l'humour, des issues avec des réponses, un site (très) détaillé etc. Et en plus en Docker, lui aussi suivi.

Voici par exemple de quoi l'installer très simplement pour une utilisation locale, avec MySQL (mais fonctionne aussi sans mySQL avec sqlite directement) et avec les MàJ via Watchtower

version: '3'
services:
  cyphtsql:
    image: mariadb:10
    restart: always
    container_name : cyphtsql
    volumes:
      - /home/aerya/docker/webmail/cypht/sql:/var/lib/mysql
    environment:
      - MYSQL_ROOT_PASSWORD=123
      - MYSQL_DATABASE=abc
      - MYSQL_USER=def
      - MYSQL_PASSWORD=456
    labels:
      - com.centurylinklabs.watchtower.enable=true
  cypht:
    image: sailfrog/cypht-docker:latest
    restart: always
    container_name : cypht
    volumes:
      - /home/aerya/docker/webmail/cypht/users:/var/lib/hm3/users
    ports:
      - "6723:80"
    environment:
      - CYPHT_AUTH_USERNAME=denis
      - CYPHT_AUTH_PASSWORD=motdepasse
      - CYPHT_DB_HOST=cyphtsql
      - CYPHT_DB_NAME=abc
      - CYPHT_DB_USER=def
      - CYPHT_DB_PASS=456
      - CYPHT_SESSION_TYPE=DB
    labels:
      - com.centurylinklabs.watchtower.enable=true

Il prend en charge IMAP, JMAP, SMTP, POP3 et RSS et on peut choisir d'inclure ou non chaque compte ajouté dans la "boîte de réception globale".

On peut évidemment personnaliser la langue, la timezone, le thème, ce sur quoi on veut ouvrir (tout, non lus etc).

Pensez à autoriser l'enregistrement automatique ;)

On peut aussi bien entendu ajouter facilement des comptes Google, Apple, Microsoft and co

Je relaie mes articles sur mon Discord via le site public de MonitoRSS et je voulais m'ajouter d'autres flux mais, et c'est normal, il souffre de quelques limitations quand on passe par le site.

MonitoRSS permet de lier un bot à notre compte Discord et ce bot peut être utilisé sur plusieurs serveurs et relayer plusieurs flux RSS.

Du coup, en route pour l'auto-hébergement !

Il faut commencer par créer une application et un bot Discord

Lui donner un p'tit nom, éventuellement lui mettre un avatar et une rapide description

Puis lui préciser l'URL de redirection après l'authentification. Ce sera l'URL de notre MonitoRSS suivie de /authorize

Les client ID & Secret serviront à configurer MonitoRSS

Vient enfin la création du bot

Le token servira à configurer MonitoRSS

On peut ensuite passer à l'installation, en Docker, et la configuration du bot. Pour des détails la Doc est bien fournie.

J'hébergerai la config dans /home/aerya/docker/mrss/. Je clone donc le git de ce même dossier.

git clone https://github.com/synzen/MonitoRSS-Clone.git .

Le . indiquant de cloner dans le dossier en cours et non un nouveau

Modifier le docker-compose pour l'adapter à notre configuration

version: "3.5"
services:
  mrss-redis:
    container_name: mrss-redis-container
    restart: on-failure:5
    image: redis:alpine
  mrss-mongo:
    container_name: mrss-mongodb-container
    restart: on-failure:5
    command: mongod --port 27017
    image: mongo:latest
    volumes:
      - '/home/aerya/docker/mrss/db:/data/db'
  mrss-bot:
    container_name: mrss-bot-container
    restart: on-failure:3
    build: .
    depends_on:
      - mrss-mongo
    environment:
      - DRSS_START=bot
      - DRSS_BOT_TOKEN=xxx
      - DRSS_DATABASE_URI=mongodb://mrss-mongo:27017/rss
  mrss-web:
    container_name: mrss-web-container
    build: .
    restart: on-failure:3
    depends_on:
      - mrss-redis
      - mrss-mongo
    ports:
      - "8082:8081"
    environment:
      - DRSS_START=web
      - DRSSWEB_BOT_TOKEN=xxx
      - DRSSWEB_DATABASE_REDIS=redis://mrss-redis:6379
      - DRSSWEB_DATABASE_URI=mongodb://mrss-mongo:27017/rss
      - DRSSWEB_BOT_REDIRECTURI=https://mrss.upandclear.org/authorize
      - DRSSWEB_BOT_CLIENTID=938683932843589633
      - DRSSWEB_BOT_CLIENTSECRET=xxx

Une fois qu'on y a modifié le chemin de montage de MongoDB, mis token/client ID et client Secret de notre bot et l'URL de redirection, on peut lancer tout ça

docker-compose up -d

Il va construire 2 images au passage et lancer la stack.

Creating network "mrss_default" with the default driver
Building mrss-bot
[...]
Successfully tagged mrss_mrss-bot:latest
WARNING: Image for service mrss-bot was built because it did not already exist. To rebuild this image you must use `docker-compose build` or `docker-compose up --build`.
Building mrss-web
[...]
Successfully tagged mrss_mrss-web:latest
WARNING: Image for service mrss-web was built because it did not already exist. To rebuild this image you must use `docker-compose build` or `docker-compose up --build`.
Creating mrss-redis-container   ... done
Creating mrss-mongodb-container ... done
Creating mrss-bot-container     ... done
Creating mrss-web-container     ... done

On peut maintenant aller sur notre site

Il faut commencer par inviter le bot sur le serveur Discord et l'autoriser à lire/envoyer des messages et y intégrer des liens

Même chose enfin pour accéder au panneau de contrôle (bouton Control Panel donc)

On arrive sur notre interface de gestion des flux

Pour ajouter un flux RSS il suffit de sélectionner le serveur concerné à gauche puis d'entrer une URL de flux à suivre et un salon où poster automatiquement

On peut laisser tel quel, c'est le cas avec mes articles de blog par exemple. Ils seront relayés quelques minutes après leur publication.

Mais on peut aussi affiner la publication d'un flux RSS en en modifiant le contenu, l'aspect voire en les filtrant via des expressions.

Y'a 1 mois j'ajoutais les commentaires via Commento++.

Je viens de remplacer ça par Isso et c'est mon dernier choix Jean-Pierre ! (pour l'instant)

C'est pas parfait, du moins comme je le voudrais, mais c'est pas mal. J'avais un souci avec Commento++, je ne recevais aucune notification de commentaire. Et je ne peux pas aller voir chaque article, en quête de commentaires ou de SPAM.

Le mieux reste encore de passer par Discord mais tout le monde n'y est pas.

Pour l'installer c'est pas compliqué, ça passe par Docker

docker run -d \
--name=blogisso \
--restart always \
-p 0.0.0.0:19312:8080 \
-v /home/aerya/docker/blog/isso/config:/config \
-v /home/aerya/docker/blog/isso/db:/db \
isso

Il faut configurer la partie serveur et ensuite la cliente, cette dernière n'étant que le code qui sera à insérer dans le thème Ghost.

Voici par exemple mon client

<section class="post-full-comments">
    <script
      data-isso="https://isso.upandclear.org/"
      data-isso-css="true"
      data-isso-lang="fr"
      data-isso-vote="true"
      data-isso-reply-to-self="false"
      data-isso-require-author="true"
      data-isso-require-email="true"
      data-isso-reply-notifications="true"
      data-isso-max-comments-top="10"
      data-isso-max-comments-nested="5"
      data-isso-reveal-on-click="5"
      data-isso-gravatar="true"
      data-isso-avatar="false"
      src="//isso.upandclear.org/js/embed.min.js"></script>
<section id="isso-thread"></section>

Et on l'insère ensuite dans son fichier post.hbs du thème utilisé, dans la partie des commentaires sous {{!-- If you want to embed comments, this is a good place to do it! --}}

En revanche navré pour les quelques personnes qui avaient déjà laissé des commentaires mais ils ont disparu.

Besoin de créer un graph de vos disques et partitions ? Prenez quelques secondes :

Télécharger le script

curl https://raw.githubusercontent.com/pavlozt/serverviz/master/serverviz >serverviz

Le rendre exécutable

chmod +x serverviz

Le lancer

python3 serverviz > graph.dot

En copier les données (cat graph.dot) dans un site de mise en forme tel que https://edotor.net

Tadaaaa

Merci Pavlozt !

Je n'avais utilisé ZFS que pour de la station de travail et je trouve mon serveur parfois poussif. Certes, cet un agrégat de petits SATA, en RAIDz-1, mais ça me surprend.

Il faut que je regarde de plus près la configuration de ZFS mais je voulais aussi faire un test de vitesse qui me servirait notamment de point de comparaison pour la suite.

J'utilise Bonnie++, (vieil) utilitaire de benchmark de système de fichiers dont voici le man ("manuel") et le site de son auteur.
On l'installe tout simplement via apt par exemple

sudo apt-get install bonnie++

Il y a plusieurs manière de l'utiliser, voici un exemple simple :

bonnie++ -d /rpool/ -s 48G -n 2 -f -b -u root

-d /rpool = où effectuer le test. /rpool étant un de mes pools RAIDz-1
-s 48G : taille du fichier de test, Bonnie++ recommande le double de la RAM
-n 2 : nombre de fichiers utilisés pour le test
-f : fast mod
-b : pas de buffer d'écriture (pour un accès direct et donc plus réaliste)
-u root : utilisateur d'exécution

[root@pve aerya]$ bonnie++ -d /rpool/ -s 48G -n 2 -f -b -u root
Using uid:0, gid:0.
Writing intelligently...
done
start 'em...done...done...done...done...done...
Create files in sequential order...done.
Stat files in sequential order...done.
Delete files in sequential order...done.
Create files in random order...done.
Stat files in random order...done.
Delete files in random order...done.
Version  2.00       ------Sequential Output------ --Sequential Input- --Random-
                    -Per Chr- --Block-- -Rewrite- -Per Chr- --Block-- --Seeks--
Name:Size etc        /sec %CP  /sec %CP  /sec %CP  /sec %CP  /sec %CP  /sec %CP
pve             48G            311m  17  226m  22            613m  29 170.4   5
Latency                        3024ms     542ms               423ms     529ms
Version  2.00       ------Sequential Create------ --------Random Create--------
pve                 -Create-- --Read--- -Delete-- -Create-- --Read--- -Delete--
              files  /sec %CP  /sec %CP  /sec %CP  /sec %CP  /sec %CP  /sec %CP
                  2  2048   0 +++++ +++  2048   0  2048   0 +++++ +++  2048   0
Latency               338ms       8us     480ms     348ms      15us     449ms
1.98,2.00,pve,1,1641109158,48G,,8192,5,,,318369,17,231080,22,,,627973,29,170.4,5,2,,,,,29,0,+++++,+++,30,0,41,0,+++++,+++,32,0,,3024ms,542ms,,423ms,529ms,338ms,8us,480ms,348ms,15us,449ms

Le résultat est particulièrement imbuvable et on le transcrit en HTML via le code Perl "bon_csv2html" sous la forme de

echo "Résultats" | bon_csv2html > Résultats.html

Comme je suis sur un serveur, je place le résultat dans un serveur Web format Docker

docker run -d \
--name=bonniehtml \
-p 8053:8080 \
-v /home/aerya/docker/bonniehtml:/var/www/html \
trafex/php-nginx

Donc

echo "1.98,2.00,pve,1,1641109158,48G,,8192,5,,,318369,17,231080,22,,,627973,29,170.4,5,2,,,,,29,0,+++++,+++,30,0,41,0,+++++,+++,32,0,,3024ms,542ms,,423ms,529ms,338ms,8us,480ms,348ms,15us,449ms" | bon_csv2html > /home/aerya/docker/bonniehtml/Résultats.html

Ce qui me les sert bien en version Web (et lisible)

Maintenant faut bien entendu interpréter les résultats. Ce qui m'intéressait dans l'immédiat ce sont les M/sec des I/O.
Soit 613MB/s en écriture (input) et 311MB/s en lecture (Output).
Ce que je peux confirmer avec dd :

TEST en écriture

[root@pve aerya]$ time sh -c "dd if=/dev/zero of=/rpool/test.tmp bs=4k count=2000000 && sync"
2000000+0 records in
2000000+0 records out
8192000000 bytes (8.2 GB, 7.6 GiB) copied, 9.71033 s, 844 MB/s

real	0m12.822s
user	0m1.181s
sys	0m7.522s

TEST en lecture

[root@pve aerya]$ time sh -c "dd if=/rpool/test.tmp of=/dev/null bs=4k"
2000000+0 records in
2000000+0 records out
8192000000 bytes (8.2 GB, 7.6 GiB) copied, 26.5967 s, 308 MB/s

real	0m26.598s
user	0m1.197s
sys	0m25.379s

Hey ! Blaireau ! Pourquoi tu nous parles de bonnie++ alors que tu as la même en plus simple et rapide avec dd ?!

Parce que Bonnie++ est plus complet (latence etc) et que c'est un point de comparaison plus fiable et complet quand on veut tweaker un peu ZFS.

This is a brand new site that's just getting started. Things will be up and running here shortly, but you can subscribe in the meantime if you'd like to stay up to date and receive emails when new content is published!