JL

Auto-hébergement (1/n) – la machine 🖥️

Tue, 23 Jan 2024 00:00:00 +0000

Récemment, le sujet de l’auto-hébergement revient en force lors des discussions à la machine à café. La volonté de s’émanciper de l’emprise de Google et consort alliée à l’envie de « tester des trucs » motivent certains de mes collègues à gérer un petit serveur domestique à la maison.

En ce qui me concerne, c’est la découverte de l’application de gestion de photos et vidéos Immich, grâce à un collègue, qui a servi de déclencheur pour rejoindre le mouvement.

Ça marche sur ma machine !

— N’importe quel développeur
au moins une fois dans sa vie.

Commence ainsi aujourd’hui une série d’article qui iront du choix de la machine physique jusqu’à l’installation de la fameuse application Immich.

Sommaire

Le choix de la machine
Préparation avant installation
- Ajout d’un second SSD
- Mise à jour du firmware
Prochainement…

Le choix de la machine

Après échange rapide avec quelques personnes de mon entourage gérant déjà un petit serveur domestique, j’ai opté pour une solutions HP EliteDesk G4.

Quand bien même il s’agit de matériel destiné théoriquement à de la bureautique, ça reste du matériel professionnel, avec des caractéristiques techniques séduisantes tout en restant très compact.

Mais surtout, une machine de ce type est facilement trouvable sur le marché de l’occasion entre 100 et 400 € suivant le modèle ciblé.

Figure 1. HP EliteDesk 800 G4 Mini — faces avant et arrière

Pour ma part, j’ai opté pour une machine HP EliteDesk 800 G4 Mini, trouvée à 200 € sur BackMarket. Il présente les caractéristiques suivantes :

Dimensions

160 × 117 × 18.5 mm

Alimentation

alimentation externe 65 W (19,5 V 3,33 A)

CPU

Intel Core i5-8500T @2,1 GHz (6 cœurs)

Mémoire

16 Gio de RAM (2 × 8 Gio DDR4-2666 SODIMM, maximum supporté : 32 Gio)

Stockage

1 SSD NVMe de 512 Gio

Connectique

6 ports USB-A (2 en face avant, 4 à l’arrière),
1 port USB-C (en face avant),
3 ports DP,

suivant le modèle, un port HDMI, USB-C avec support du mode vidéo ou même VGA peut remplacer le port DP central.
2 ports audio JACK (1 casque et 1 casque+micro),
1 port RJ-45 Ethernet Gigabit.

Emplacements d’extension

2 emplacements M.2 PCIe ×4 2280/2230 (1 libre pour un second SSD NVMe, on y reviendra plus tard)
1 emplacement M.2 PCIe ×1 2230 pour éventuellement ajouter une carte Wi-Fi,

1 baie pouvant accueillir un disque SATA 2.5”.

Je me suis rapidement rendu compte que la présence de la baie SATA était difficilement compatible avec l’ajout d’un second SDD au format M.2 2280 ^[1] dans l’emplacement situé juste en dessous. Mécaniquement, ça passe, mais ça frotte. J’ai préféré retirer la baie pour mon usage.

Figure 2. HP EliteDesk 800 G4 Mini — sous le capot

Préparation avant installation

Ajout d’un second SSD

Si je compte bien à terme mettre en place une solution de sauvegarde des données contenues sur ce serveur, j’aimerais disposer d’un premier filet de sécurité en cas de panne du support de stockage.

Pour cela, j’ai décidé de profiter de la présence d’un second connecteur M.2 PCIe ×4 pour installer un SSD NVMe supplémentaire, de même capacité que le premier, ceci afin de mettre en place une solution RAID1.

Ainsi, si l’un des disque vient à lâcher, suivant la panne j’aurais de bonnes chances de pouvoir revenir à un fonctionnement normal en remplaçant simplement le disque défectueux, sans avoir à souffrir d’une perte de données, et donc sans avoir à recourir à la restauration d’un backup. Mieux, je pourrais temporairement (ne jouons pas avec le feu) continuer à faire fonctionner le serveur sur un seul disque de manière transparente.

Mise à jour du firmware

Après avoir trouvé la bonne touche de clavier sur laquelle appuyer pour accéder à la configuration du firmware (F10), première bonne surprise : il est possible de mettre à jour celui-ci directement depuis l’interface de configuration. Évidemment, penser à fournir au préalable un accès Internet à la machine pour que l’utilitaire puisse aller chercher la dernière version du firmware sur les serveurs d’HP.

choix purement personnel, mais j’ai aussi profiter d’être dans la configuration du firmware pour désactiver le module TPM de la machine, et l’utilisation du secure boot. Je n’ai pas de temps à consacrer à ces sujets pour le moment, on verra plus tard éventuellement.

Prochainement…

Le prochain article de cette série se concentrera sur l’installation du système d’exploitation après configuration des deux disques dans une grappe RAID 1.

1. 2280 pour 80 mm de longueur

Chiffrement transparent des données utilisateurs avec LUKS/dm-crypt 🔐

Tue, 18 Aug 2020 00:00:00 +0000

Jusqu’à la version 17.10, Ubuntu proposait une option permettant de chiffrer son répertoire utilisateur. Très simple à mettre en œuvre, il suffisait de cocher une case lors d’une étape de l’installation pour que les données de l’utilisateur soient protégées, par exemple en cas de vol de l’ordinateur.

Cette solution avait l’avantage de proposer une solution de chiffrement des données transparente pour l’utilisateur, puisque le déchiffrement se faisait automatiquement lors de l’ouverture d’une session utilisateur.

« Crypter » est à « décrypter » ce que « truire » est à « détruire » : ça ne veut rien dire !

— L’auteur de ce blog
Vous voulez en savoir plus ?

Cette option n’est plus proposée à l’installation dans les versions récentes d’Ubuntu et eCryptfs est considéré comme déprécié, en faveur de l’utilisation du standard en terme de chiffrement dans le monde Linux, LUKS mis en œuvre à l’aide de dm-crypt.

La seule option proposée lors de l’installation d’Ubuntu et reposant sur LUKS/dm-crypt consiste à chiffrer totalement son système, pas uniquement le répertoire utilisateur. Ainsi, le démarrage nécessite la saisie d’une passphrase pour déchiffrer le disque pour que le système puisse démarrer (je schématise). Des données sécurisées, certes, mais une perte de confort d’utilisation.

Dans cet article nous allons voir comment installer la dernière version d’Ubuntu en date (20.04), en mettant en œuvre du chiffrement avec LUKS/dm-crypt, tout en conservant (presque) le confort d’utilisation que procurait la solution eCryptfs.

Sommaire

Préparatifs avant installation
Installation d’Ubuntu 20.04
Avant de redémarrer !
Démarrage
Et au final, content ?
Références

Préparatifs avant installation

Avant de procéder à l’installation, nous allons passer par la ligne de commandes pour préparer le disque avant d’utiliser le programme d’installation d’Ubuntu.

Invites de commandes

Dans les exemples de commandes shell de cet article :

l’invite # indique que la commande doit être exécutée avec les privilèges root, soit directement en tant qu’utilisateur root, soit en utilisant la commande sudo.
L’invite $ indique que la commande doit être exécutée sans privilège root.

Démarrer une session live à l’aide d’une clé USB d’installation d’Ubuntu, puis ouvrir un terminal.

la session live doit être lancée en mode UEFI.

Identifier le chemin du périphérique bloc ^[1] correspondant au disque sur lequel dérouler l’installation, à l’aide de la commande lsblk:

Dans la suite de ce guide, nous utiliserons le disque /dev/sda pour illustrer les commandes à exécuter.
Ce guide part du principe que le disque /dev/sda est vierge de tout volume LVM. Si tel n’est pas le cas, supprimer toutes traces liées à LVM du disque /dev/sda avant de dérouler la suite du guide :
```
# vgremove -y -ff <volume-group-name>(1)
# pvremove -y -ff /dev/sda*(2)
```
1 Supprime un groupe de volume.

2 Supprime tous les volumes physiques des partitions du disque /dev/sda.

Réinitialiser le partitionnement du disque /dev/sda
```
# sgdisk --zap-all /dev/sda \(1)
    && partprobe(2)
```
1 Supprime les structures de données MBR et GPT du disque /dev/sda.

2 Informe le système d’exploitation des changements apportés aux tables de partitions.

Partitionner le disque /dev/sda :

créer une partition système EFI :

# sgdisk -n1:0:+512M \(1)
    -t1:EF00 \(2)
    -c1:esp \(3)
    /dev/sda

1	Crée une nouvelle partition numérotée `1`, de taille 512 Mio ^[2]
2	Spécifie le type de la partition `1`. Ici `EF00` désigne une partition système EFI ^[3].
3	Nom donné à la partition : « `esp` », pour EFI System Partition.

créer une partition destinée à être gérée par LVM :

# sgdisk -n2:0:0 \(1)
    -t2:8E00 \(2)
    -c2:main \(3)
    /dev/sda

1 Crée une nouvelle partition numérotée 2, occupant tout l’espace libre restant du disque.

2 Spécifie que la partition 2 est de type LVM.

Nomme la partition « main ».

Le système d’exploitation utilise ce libellé pour définir un raccourci vers cette partition dans le système de fichiers. On pourra par la suite référencer cette partition à l’aide du chemin /dev/disk/by-partlabel/main.

Vérifier le partitionnement du disque /dev/sda :

# sgdisk --print /dev/sda

La commande doit retourner un résultat cohérent avec les options indiquées dans les précédentes commandes.

Exemple 1. résumé du partitionnement d’un disque avec sgdisk

# sgdisk --print /dev/sda
...
Number Start (sector) End (sector)  Size      Code  Name
     1           2048      1050623  512.0 MiB EF00  esp
     2        1050623    500118158  238.0 GiB 8E00  main

Formater la partition EFI :

# mkfs.fat -F32 /dev/disk/by-partlabel/esp

Initialiser la partition main en tant que volume physique pour LVM :
```
# pvcreate /dev/disk/by-partlabel/main
```
Créer un groupe de volumes LVM en y incluant la partition main :
```
# vgcreate vgmain \(1)
    /dev/disk/by-partlabel/main(2)
```
1 Nom donné au groupe de volumes : « vgmain » (🤷‍♂️).

2 Chemin des périphériques blocs à ajouter au groupe de volumes (ici, une seule partition).
Créer des volumes logiques dans vgmain :
- créer un premier volume logique pour la racine du système de fichiers :
  # lvcreate -y --name root \(1) --size 50G \(2) vgmain
  1 Nom donné au volume logique : « root ».
  
  2 Taille du volume logique : 50 Gio.
- Créer un deuxième volume logique pour un espace swap :
  # lvcreate -y --name swap \(1) --size 2G \(2) vgmain
  1 Nom donné au volume logique : « swap ».
  
  2 Taille du volume logique : 2 Gio.
- Créer un dernier volume logique destiné à être chiffré :
  # lvcreate -y --name crypt \(1) --extents 100%FREE \(2) vgmain
  1 Nom donné au volume logique : « crypt ».
  
  2 Le volume logique occupera 100% de l’espace disponible.

Chiffrer le volume logique crypt :

# cryptsetup luksFormat \(1)
    /dev/mapper/vgmain-crypt(2)

Aucune option spécifiée, les options par défaut suivantes sont utilisées :

--type luks: Utilise la spécification de chiffrement de disque LUKS. Plus précisément, c’est LUKS2 qui est mis en œuvre depuis la version 2.1.0 de cryptsetup.
--cipher aes-xts-plain64: Algorithme de chiffrement.
--key-size 512: Taille de la clé de chiffrement.
--hash sha256: Algorithme de hachage utilisé pour la dérivation de clé ^[4].
--iter-time 2000: Nombre d’itération de la fonction de dérivation de clé.
--use-urandom: Utilise la source d’entropie /dev/urandom.
--verify-passphrase: Demande confirmation de la phrase de passe.

2 Chemin du périphérique bloc à chiffrer.

La commande demande la saisie d’une passphrase pour chiffrer le périphérique bloc, ainsi que la confirmation de cette passphrase.

L’objectif étant de déchiffrer automatiquement le répertoire utilisateur après l’authentification, le mot de passe du compte utilisateur qui sera créé pendant l’installation devra être identique à la passphrase saisie ici.

Lors de mes tests dans une machine virtuelle avec seulement 2 Gio de mémoire, la commande cryptsetup luksFormat se terminait par un laconique « Processus arrêté » affiché dans la sortie standard. Ceci est lié à la fonction de dérivation de clé Argon2i ^[5] très gourmande en mémoire. Veiller donc à avoir suffisamment de mémoire sur la machine ou alors ajouter l’option --pbkdf-memory <max-memory-in-kilobytes> à la ligne de commande pour limiter la quantité de mémoire utilisée.

Déverrouiller le volume chiffré :

# cryptsetup open --type=luks \
    /dev/mapper/vgmain-crypt \(1)
    home-jl(2)

1	Chemin du périphérique bloc chiffré à rendre accessible.
2	Nom donné au périphérique bloc au travers duquel le contenu déchiffré sera accessible. Le périphérique bloc créé est à présent accessible avec le chemin `/dev/mapper/home-jl`.

Formater le périphérique bloc :
```
# mkfs -t ext4 /dev/mapper/home-jl
```
Sans cette étape, le périphérique bloc n’est pas visible pendant l’installation d’Ubuntu.

Installation d’Ubuntu 20.04

Nous allons dérouler normalement l’installation d’Ubuntu à l’aide du programme dédié.

Lancer le programme d’installation.
Arrivé à l’étape de sélection du type d’installation, sélectionner Autre chose, puis cliquer sur Continuer.

Figure 1. Installation d’Ubuntu — sélection du type d’installation
Dans l’outil de partitionnement, définir /dev/mapper/vgmain-root en tant que racine du système de fichiers.

Figure 2. Installation d’Ubuntu — définition de la racine du système de fichiers
Sélectionner ensuite /dev/mapper/home-jl pour le répertoire utilisateur.

Bien faire attention à saisir /home/jl en point de montage. Nous verrons plus tard comment faire en sorte de déverrouiller puis monter le volume après authentification de l’utilisateur.

Figure 3. Installation d’Ubuntu — sélection du volume pour le répertoire utilisateur
Indiquer /dev/mapper/vgmain-swap comme espace d’échange, puis cliquer sur Installer maintenant

Figure 4. Installation d’Ubuntu — définition de l’espace swap
Confirmer les changements à appliquer en cliquant sur Continuer.

Figure 5. Installation d’Ubuntu — confirmation du partitionnement

Arrivé à l’étape « Qui êtes-vous ? », saisir les informations du compte utilisateur à créer, puis cliquer sur Continuer pour terminer l’installation.

pour faire en sorte de déchiffrer le volume du répertoire utilisateur à la connexion de celui-ci, il est primordial de saisir un mot de passe identique à la passphrase saisie lors du chiffrement du volume.

Figure 6. Installation d’Ubuntu — création du compte utilisateur

À la fin de l’installation, ne pas redémarrer l’ordinateur. Il nous reste des choses à faire.

Avant de redémarrer !

Après l’installation il nous reste à faire en sorte que l’ouverture d’une session utilisateur entraîne le déchiffrement puis le montage de son volume personnel. Nous allons également prendre soin de chiffrer l’espace swap.

Si par erreur un redémarrage a eu lieu à la fin de l’installation, penser à déverrouiller manuellement le volume chiffré avant de dérouler les instructions ci-dessous.

Configurer des points de montages pour faire un chroot dans l’environnement installé :

# mount /dev/mapper/vgmain-root /mnt \(1)
    && mount /dev/disk/by-partlabel/esp /mnt/boot/efi \
    && mount /dev/mapper/home-jl /mnt/home/jl
# mount --rbind /dev  /mnt/dev \(2)
    && mount --rbind /proc /mnt/proc \
    && mount --rbind /sys  /mnt/sys
# cp /etc/resolv.conf /mnt/etc/resolv.conf(3)
# chroot /mnt(4)

1	Monte les différents périphériques pour reproduire le système de fichiers de la machine installée.
2	Monte des pseudo systèmes de fichiers de l’hôte.
3	Copie le fichier de résolution des DNS.
4	change root

Copier des fichiers de configuration manquants dans le répertoire utilisateur :
```
# cp /etc/skel/.* /home/jl
```
Créer un script de déverrouillage du volume logique chiffré /usr/local/bin/pam-crypt-open.sh
```
#!/bin/sh

CRYPT_USER="jl"
MAPPER_NAME="home-$CRYPT_USER"
MAPPER="/dev/mapper/$MAPPER_NAME"

if [ "$PAM_USER" = "$CRYPT_USER" ] && [ ! -e $MAPPER ]
then
  tr '\0' '\n' | /sbin/cryptsetup open --type=luks /dev/mapper/vgmain-crypt "$MAPPER_NAME"
fi
```
Ce script permet d’utiliser le mot de passe saisi par l’utilisateur lors de l’ouverture de session pour déchiffrer le volume /dev/mapper/vgmain-crypt (si l’identifiant utilisateur est celui attendu et si le volume n’est pas déjà ouvert).
Attribuer les droits d’exécution à ce script
```
# chmod u+x /usr/local/bin/pam-crypt-open.sh
```
Configurer pam pour rendre accessible le contenu du volume chiffré lors d’une ouverture de session :
```
# echo "auth    optional    pam_exec.so expose_authtok /usr/local/bin/pam-crypt-open.sh" >> /etc/pam.d/common-auth
```
Le module pam_exec permet d’appeler le script ajouté ci-dessus à l’ouverture d’une session utilisateur.
Faire en sorte de monter le volume chiffré uniquement lorsque nécessaire (à l’ouverture de session, après déchiffrement) :
```
# sed -i -e "s/$\/home\/jl\s\+ext4\s\+$defaults/\1rw,suid,dev,exec,noauto,nouser,async/" /etc/fstab
```
La commande ci-dessus modifie le fichier /etc/fstab et remplace le paramètre defaults de montage du répertoire utilisateur (qui équivaut à rw,suid,dev,exec,auto,nouser,async) par la valeur rw,suid,dev,exec,noauto,nouser,async.

Configurer le chiffrement de l’espace swap

Définir la configuration de chiffrement de l’espace swap :

# echo "swap\(1)
    /dev/mapper/vgmain-swap\(2)
    /dev/urandom\(3)
    plain,swap,cipher=aes-xts-plain64,size=256" \(4)
    > /etc/crypttab(5)

1 L’espace swap déchiffré sera accessible au travers du périphérique bloc /dev/mapper/swap.

2 Chemin du périphérique bloc à déchiffrer.

3 La clé de chiffrement est générée aléatoirement à chaque démarrage

4 Indique que le mode de chiffrement est plain, puis spécifie l’utilisation en tant qu’espace swap ainsi que les options de chiffrement.

Le fichier /etc/crypttab décrit les périphériques blocs qui sont déchiffrés au démarrage.

Ce mode de chiffrement de l’espace swap empêche son utilisation pour de l’hibernation (suspend to disk).

Mettre à jour le chemin de l’espace swap dans le fichier /etc/fstab :

# sed -i -e "s/\/dev\/mapper\/vgmain-swap/\/dev\/mapper\/swap/" /etc/fstab

Désactivier l’utilisaton de l’espace swap pour l’hibernation :

# echo "RESUME=none" > /etc/initramfs-tools/conf.d/resume && update-initramfs -u

Quitter « l’environnement » chroot :
```
# exit
```

Démonter toute l’arborescence /mnt :

# mount | grep /mnt | tac | awk '/\/mnt/ {print $3}' | xargs -i{} umount -lf {}

Nous en avons terminé dans cette session live. Nous pouvons redémarrer l’ordinateur.

Démarrage

L’installation est terminée et l’ordinateur est utilisable en l’état. Nous allons malgré tout renforcer la sécurité de cette installation en faisant en sorte de démonter le répertoire personnel, puis verrouiller le volume chiffré lorsque l’utilisateur clôt sa session.

Ouvrir un terminal.
Configurer le démontage de /home/jl lors de la fermeture de session

Après fermeture d’une session utilisateur, systemd arrête automatiquement le service user@1000.service (où 1000 est le PID de l’utilisateur jl). En spécifiant que le point de montage /home/jl requiert le fonctionnement de ce service, systemd le démontera automatiquement à l’arrêt de celui-ci.
- Éditer le fichier de configuration systemd correspondant au point de montage /home/jl (mount unit) :
  # systemctl edit home-jl.mount
  Et ajouter une dépendance vers l’unité user@1000.service :
  [Unit] Requires=user@1000.service
  Enregistrer puis quitter l’éditeur.
  
  En procédant ainsi, on introduit une dépendance circulaire qu’il faut résoudre en modifiant la configuration du service user@1000.service.
- Éditer l’unité de service user@1000.service :
  # systemctl edit user@1000.service
  Et ajouter les contraintes suivantes :
  [Unit] Requires=home-jl.mount After=home-jl.mount

Configurer le verrouillage du volume chiffré à la fermeture de session.

Pour parvenir à cet objectif, nous allons définir un nouveau service qui démarre au déverrouillage du volume chiffré et se termine au démontage du répertoire /home/jl, tout en déclenchant le verrouillage du volume.

Créer le service cryptsetup-jl.service :

# systemctl edit --full --force \(1)
    cryptsetup-jl.service(2)

1	Combinaison d’options à saisir pour créer un nouveau service : `--full` spécifie d’éditer le fichier de configuration complet. `--force` force la création du fichier s’il n’existe pas.
2	Nom donné au service.

Avec la configuration suivante :

[Unit]
DefaultDependencies=no
BindsTo=dev-mapper-vgmain\x2dcrypt.device
After=dev-mapper-vgmain\x2dcrypt.device
BindsTo=dev-mapper-home\x2djl.device
Requires=home-jl.mount
Before=home-jl.mount
Conflicts=umount.target
Before=umount.target

[Service]
Type=oneshot
RemainAfterExit=yes
TimeoutSec=0
ExecStop=/sbin/cryptsetup close home-jl

[Install]
RequiredBy=dev-mapper-home\x2djl.device

dev-mapper-vgmain\x2dcrypt.device est le « fichier » de configuration systemd désignant le périphérique bloc /dev/mapper/vgmain-crypt (on parle de device unit configuration). Cette chaîne de caractère est obtenu à l’aide de la commande systemd-escape:

$ systemd-escape -p \(1)
    /dev/mapper/vgmain-crypt (2)

1	`-p` indique que la valeur qui suit est un chemin de fichier.
2	Chemin du périphérique bloc.

Activer le service cryptsetup-jl.service :

# systemctl enable cryptsetup-jl.service

Et au final, content ?

Éh bien oui, ça fonctionne très bien. Mon répertoire utilisateur est déverrouillé lorsque j’ouvre une session utilisateur et est automatiquement reverouillé lorsque je la clos. Dans l’absolu on obtient un système moins sécurisé qu’avec un disque totalement chiffré, mais je pense que la facilité d’utilisation est également à prendre en compte. Le fait d’avoir un ordinateur sur lequel les données utilisateur — les plus critiques donc — sont protégées de manière transparente facilite selon moi l’adoption du chiffrement. Certains ergoteront qu’utiliser le même mot de passe pour le compte utilisateur et pour le chiffrement du volume présente un risque. Le risque me paraît acceptable dès lors que j’opte pour un mot de passe suffisamment long et non-trivial.

Il reste néanmoins un petit bémol pour en faire une solution totalement aboutie. Lorsque je serai amené à changer de mot de passe utilisateur, je devrai prendre soin de modifier manuellement la passphrase du volume chiffré pour les garder identiques. L’intégration d’eCryptfs à PAM était complète et prenait en charge ce cas d’utilisation. Il existe un projet poussant un peu plus loin l’intégration de cryptsetup à PAM, mais je n’ai pas pris le temps de le tester.

Malgré cette réserve, j’ai décidé de conserver cette configuration pour mon usage quotidien. Je ne change pas de mot de passe si souvent que ça et, le moment venu, ce sera une bonne opportunité de me replonger dans cet article. À mon moi du futur qui cherche comment changer la passphrase du volume chiffré, la réponse est là :

# cryptsetup luksChangeKey /dev/mapper/vgmain-crypt

Dernier point positif que je découvre seulement à la conclusion de cet article : même si ce n’était pas l’objectif recherché, peut-être ai-je gagné en confort d’utilisation au quotidien, tant LUKS/dm-crypt semble une solution plus performante qu’eCryptfs.

Références

Encrypting disks on Ubuntu 19.04 : https://medium.com/@chrishantha/encrypting-disks-on-ubuntu-19-04-b50bfc65182a
Full Disk Encryption Howto 2019 : https://help.ubuntu.com/community/Full_Disk_Encryption_Howto_2019
Encrypting a non-root file system : https://wiki.archlinux.org/index.php/Dm-crypt/Encrypting_a_non-root_file_system
Encryption options for LUKS mode : https://wiki.archlinux.org/index.php/Dm-crypt/Device_encryption#Encryption_options_for_LUKS_mode
Mounting at login : https://wiki.archlinux.org/index.php/Dm-crypt/Mounting_at_login
Swap encryption : https://wiki.archlinux.org/index.php/Dm-crypt/Swap_encryption
How to Change Your LUKS Encryption Passphrase : https://www.maketecheasier.com/change-luks-encryption-passphrase/

1. block device dans la langue de Shakespeare, mais j’essaie d’employer des termes français quand c’est possible.

2. Mio pour « mébioctet ». 1 Mio = 2²⁰ octets = 1 048 576 octets, alors que 1 Mo = 10⁶ octets = 1 000 000 octets. Voir https://fr.wikipedia.org/wiki/Octet.

3. Voir les codes hexadécimaux des différents types de partitions : https://askubuntu.com/questions/703443/gdisk-hex-codes

4. Voir la description des métadonnées cryptographique : https://wiki.archlinux.org/index.php/Data-at-rest_encryption#Cryptographic_metadata

5. Voir article Wikipédia sur la fonction de dérivation de clé Argon2 : https://fr.wikipedia.org/wiki/Argon2

Démarrer un projet basé sur Ruby 💎

Sat, 29 Feb 2020 00:00:00 +0000

Sommaire

RVM (Ruby Version Manager)
- Installation
- Quelques commandes utiles
Gestion des dépendances
Démarrer un nouveau projet

Tiens ! Si je jetais un œil à mon blog ? Mince, j’ai changé de PC depuis la dernière fois… Ah ! Il faut que j’installe Ruby 💎🤔…

— Bibi

Ce blog utilise Jekyll, générateur de site statique en Ruby. Ce n’est pas un environnement technique que j’utilise au quotidien et ce blog est mis à jour suffisamment rarement pour que le garbage collector de ma mémoire ait malheureusement fait son office.

Le temps passé à réinstaller toute la stack justifie donc l’écriture d’un article « pense-bête », une sorte de B-A, BA ^[1] de l’installation d’une stack Ruby 💎 dans un environnement Linux.

Cet article est loin d’être exhaustif sur l’environnement Ruby. Il ne fait qu’aborder une infime partie des outils et commandes proposés par la stack.

Le spectre d’outils évoqué ici suffit pour un projet basé sur un framework nécessitant un environnement Ruby (Jekyll, Asciidoctor…), mais n’est clairement pas suffisant pour se lancer dans un réel développement en language Ruby.

RVM (Ruby Version Manager)

J’aurais pu me contenter d’un sudo apt install ruby, mais tout comme je suis parfois amené à jongler entre plusieurs version de Node.js, je pourrais avoir à gérer plusieurs versions de Ruby selon les projets dans lesquels je me lance. C’est là qu’intervient RVM.

RVM est à Ruby ce que NVM est à Node.js. Il permet de gérer sur un même OS plusieurs environnements d’exécution Ruby. De multiples interpréteurs sont disponibles à l’installation (Ruby MRI, JRuby…), chacun disponible dans plusieurs versions.

L’outil permet également d’isoler les dépendances tierces des projets Ruby à l’aide de gemsets, que je n’aborderais pas ici, préférant gérer les dépendances de chacun de mes projets au sein de ceux-ci.

Installation

L’installation se fait en une commande :

$ curl -sSL https://get.rvm.io | bash -s stable

Si comme moi vous n’aimez pas qu’on trifouille dans vos fichiers de configuration (.bashrc, .profile, etc.), vous pouvez exécuter la commande d’installation avec l’option --ignore-dotfiles

$ curl -sSL https://get.rvm.io | bash -s -- --ignore-dotfiles

Mais charge à vous ensuite d’ajouter comme il vous sied les instructions nécessaires au bon fonctionnement de RVM

Quelques commandes utiles

La documentation de RVM est dense, très dense. Voici donc, en synthèse, les quelques commandes que j’utilise le plus fréquemment :

Lister les versions de Ruby disponibles à l’installation

$ rvm list known

Installer une version de Ruby

$ rvm install <VERSION>

Sélectionner une version de Ruby par défaut

$ rvm --default use <VERSION>

Sélectionner une version de Ruby pour un projet

$ rvm --ruby-version use <VERSION>

L’option --ruby-version, optionnelle, permet de sauvegarder la version spécifiée dans la commande dans un fichier .ruby-version du répertoire courant.

Ainsi inutile à l’avenir de spécifier la version en paramètre. La commande suivante, exécutée dans le répertoire projet, suffira à charger l’environnement :

$ rvm use

Mettre à jour RVM

$ rvm get stable

Faire le ménage

$ rvm cleanup all

Cette commande se révèle particulièrement utile si votre répertoire ~/.rvm prend de l’embonpoint ^[2] .

Gestion des dépendances

En Ruby, les dépendances sont appelées des gems, et l’outil de prédilection pour les gérer est Bundler. Pour continuer dans les analogies avec Node.js, Bundler est un peu le NPM de Ruby. Tout comme NPM avec Node.js, l’outil est lui aussi disponible après l’installation d’un environnement Ruby avec RVM.

Les dépendances d’un projet sont spécifiées dans un fichier Gemfile ^[3].

Voici une liste non-exhaustive des commandes proposées par Bundler :

Installer les dépendances ^[4]

$ bundle install

Cette commande interprète le contenu du fichier Gemfile pour télécharger et installer les dépendances qui y sont indiquées, ainsi que les dépendances transitives.

Lors de la première exécution la commande génère un fichier Gemfile.lock dans lequel on retrouve la liste exhaustive des gems installés ainsi que la version précise de chacun.

Si un fichier Gemfile.lock est présent lors de l’exécution de la commande, il n’y a pas de résolution des dépendances. La commande installe simplement les gems indiqués dans le fichier.

Comme évoqué plus haut, j’aime bien disposer des dépendances de mon projet directement dans celui-ci (les habitudes de travailler avec Node.js 🤷‍♂️). La commande bundle supporte des paramètres qui permettent de répondre à ce besoin :

$ bundle install \
    --path=.bundle/gems \(1)
    --binstubs=.bundle/.bin(2)

1	Indique à Bundler de télécharger les gems dans le répertoire `.bundle/gems`.
2	les exécutables des gems seront placés dans le répertoire `.bundle/.bin`.

les valeurs données à path et binstubs sont sauvegardées dans un fichier .bundle/config. Inutile donc de spécifier ces options à chaque exécution de bundle install.

Mettre à jour les dépendances ^[5]

$ bundle update --all(1)

L’option --all force Bundler à résoudre les dépendances en ignorant les gems précédemennt installés, et à regénérer le Gemfile.lock.

La commande bundle update respecte toujours les versions de gems indiquées dans le fichier Gemfile. Il faut donc modifier manuellement le fichier pour s’assurer de télécharger les versions souhaitées des dépendances.

Pour lister les gems dont les versions pourraient être mises à jour dans le fichier Gemfile, utiliser la commande suivante ^[6] :

$ bundle outdated | grep requested

Démarrer un nouveau projet

Le moment est venu de mettre en œuvre les quelques commandes passées en revu jusqu’ici.

Nous prendrons comme exemple la création d’un nouveau projet de documentation utilisateur écrit en Asciidoc à l’aide de la librairie asciidoctor.

Créer le répertoire projet

$ mkdir some-documentation-project && cd some-documentation-project

Charger l’environnement Ruby
```
$ rvm --ruby-version use 2.6
```
La version de Ruby souhaitée doit évidemment avoir été installée au préalable avec la commande suivante :

$ rvm install 2.6
Initier un nouveau fichier Gemfile
```
$ bundle init
```

Ajouter la dépendance à asciidoctor

$ echo "gem 'asciidoctor', '~> 2.0.10'" >> Gemfile

La manière dont est spécifié la version du gem asciidoctor utilise l’opérateur pessimiste ~>, aussi appelé twidlle waka ^[7]. Dans le cas présent celui-ci permet de spécifier qu’on souhaite travailler avec la version d'asciidoctor la plus haute dans la plage ≥ 2.0.10 et < 2.1.

Télécharger les dépendances du projet

$ bundle install --path=.bundle/gems --binstubs=.bundle/.bin

Travailler
…
Profits ^[8] !

1. Expression totalement désuète dont j’ai découvert l’étymologie lors de l’écriture de ce post (voir https://fr.wiktionary.org/wiki/b.a.-ba#fr). Du coup je l’ai conservée 😊.

2. Faire le ménage dans RVM : https://coderwall.com/p/x3z2ag/cleanup-rvm

3. Description du fichier Gemfile : https://bundler.io/man/gemfile.5.html

4. Description de la commande bundle install : https://bundler.io/v2.0/man/bundle-install.1.html

5. Description de la commande bundle update : https://bundler.io/v2.0/man/bundle-update.1.html

6. A Guide to Update Gems with bundle update : https://medium.com/cedarcode/reduce-fear-of-bundle-update-with-this-4-step-process-e021e8808c48

7. Ruby’s Pessimistic Operator : https://thoughtbot.com/blog/rubys-pessimistic-operator

8. Voir l’épisode S02E17 de South Park « Les Gnomes voleurs de slips » : https://i.kym-cdn.com/entries/icons/original/000/000/248/profit.jpg

Rétro-conception d’un logo

Tue, 19 Sep 2017 00:00:00 +0000

Suite à la refonte du logo du BreizhCamp, il y a un peu plus de deux ans, il m’est venu l’envie d’en réaliser une version générée de manière procédurale. Ne me demandez pas pourquoi. Moi-même, je n’en sais rien.

Peut-être son aspect très épuré m’a-t-il laisser penser que la tâche serait simple.

Ça ne doit pas être bien compliqué à coder…

— Moi
un peu optimiste en ce début 2015

À l’époque, j’avais ainsi passé quelques soirées, d’abord à reproduire le logo sous la forme d’un dessin technique, puis à en extraire quelques formules de trigo avant de finalement implémenter tout ça à la va-vite dans un plunk.

Aujourd’hui, je saisis l’opportunité de devoir alimenter ce tout nouveau ^[1] blog pour reprendre ce travail au propre.

Sommaire

Le dessin technique
Un peu de maths…
Conclusion

Le dessin technique

Appelé aussi dessin pour ceux qui aiment faire de jolies choses, mais ne savent pas dessiner.

Le logo du BreizhCamp est un triskell stylisé, composé de trois gouttes colorées.

Figure 1. Le logo du BreizhCamp — vue d’artiste

Ça, c’est la vision de l’artiste. On devine quelques irrégularités dans les arcs, les gouttes ne sont pas identiques, etc. Et c’est très bien comme ça !

Je ne suis pas un artiste. Je vais adopter un point de vue plus pragmatique pour la modélisation du logo. Ma version sera ainsi constituée de trois gouttes identiques, chacune composée de trois portions de cercles : la tête, le dos et le ventre.

Figure 2. Le logo du BreizhCamp — vue d’ingénieur

La figure de base pour la réalisation du triskell est un triangle équilatéral dont chaque sommet est le centre de l’arc de cercle constituant la tête d’une goutte.

Figure 3. Modélisation du logo

Un peu de maths…

L’objectif ici est de défricher le terrain avant de travailler sereinement sur une implémentation. Nous allons passer en revue tous les éléments nécessaires au tracé du triskell.

Première dimension à mettre en évidence : l’écart entre les gouttes du triskell. Il est représenté par le paramètre $\Delta$. Il représente concrètement la distance entre les sommets de deux triangles :

Le triangle extérieur $T_\Delta$, figure de base du triskell, connecte les centres des 3 têtes de gouttes. Il a des côtés de longueur $2\left(r_1+\Delta\cos\left(\frac{\pi}{6}\right)\right)$.
Le triangle intérieur $T_0$ est le cas particulier où $\Delta=0$. Dans cette configuration, il n’y a pas d’écart entre les gouttes. Elles sont tangentes. La longueur d’un de ses côtés est égale à $2r_1$.

Dans l’implémentation, $\Delta$ sera utilisé en tant que paramètre d’entrée pour générer le triskell.

L’angle $\theta$ sert à orienter la première goutte du triskell, avant de dessiner les suivantes, et définit ainsi l’orientation globale du dessin.

$\theta$ pourra aussi être utilisé en tant que paramètre à la génération du triskell.

Les trois gouttes constituant le triskell étant construites de la même manière, seule l’une d’entre elles est annotée sur la Figure 3.

Regardons à présent comment est constituée cette goutte.

La tête

La tête de la goutte est la portion du cercle $C_1$, de centre $B$, entre les points $A$ et $C$. Le rayon de $C_1$ est $r_1$.

$r_1$ sera également utilisé en tant que paramètre d’entrée.

Le dos

Le dos de la goutte est une portion du cercle $C_2$, de centre $O$ et de rayon $r_2$.

$C_2$ est le cercle circonscrit au triskell, tangent aux trois gouttes.

Le dos est la portion entre les points $A$, jonction avec la tête, et le point $E$, jonction avec le ventre.

Le rayon $r_2$ peut être exprimé en fonction de paramètres déjà établis. Il est égal au rayon $r_1$ ajouté à la distance $\|\vec{OB}\|$. Ce qui donne :

\[r_2=r_1+\Delta+\frac{r_1}{\cos\left(\frac{\pi}{6}\right)}\]

À ceux qui demanderaient d’où ça sort, je répondrais : SOHCAHTOA.

Le ventre

Le dos de la goutte est une portion du cercle $C_3$, de centre $D$ et de rayon $r_3$.

C’est la portion entre le point $C$, jonction avec la tête, et le point $E$, jonction avec le dos.

$r_3$ est la dernière valeur utilisée en paramètre d’entrée dans l’implémentation.

Pour former la goutte, le ventre et la tête doivent être tangents en $C$. Pour cela, le centre de $C_3$, $D$, doit être sur la droite $(BC)$.

Le point $E$ est un point d’intersection entre les cercles $C_2$ et $C_3$. Si $C_2$ et $C_3$ ne se croisent pas, c’est-à-dire si le rayon $r_3$ est trop petit, impossible de terminer la figure.

Le cas $r_{3_{min}}$

Il existe un rayon minimum, $r_{3_{min}}$ en deçà duquel le cercle $C_3$ est inclu dans le cercle $C_2$ et ne croise donc pas celui-ci.

Dans le cas particuler $r_3=r_{3_{min}}$, le ventre de la goutte est tangent à la tête, mais aussi au dos.

Figure 4. Aperçu du logo avec $r_3 = r_{3_{min}}$

Nous allons essayer de déterminer $r_{3_{min}}$.

À première vue, $r_{3_{min}}$ ne dépend que de $r_1$ et $r_2$ (qui lui-même dépend de $r_1$ et $\Delta$). Prenons cette hypothèse et essayons de simplifier la résolution en nous plaçant dans le cas particulier $\theta = 0$.

Figure 5. Modélisation pour déterminer $r_{3_{min}}$

Le point $E$ étant le point de tangence entre deux cercles, il se situe sur la droite $(OD)$ passant par les centres des deux cercles.

Intéressons-nous au vecteur $\vec{OE}$. Pour cela, introduisons l’angle $\alpha$ entre $\vec{OA}$ et $\vec{OE}$.

On peut définir $\vec{OE}$ de la manière suivante :

\[\vec{OE} \begin{pmatrix} r_2\cos(\alpha) \\ r_2\sin(\alpha) \end{pmatrix}\]

On a aussi :

\[\vec{OE}=\vec{OB}+\vec{BD}+\vec{DE}\]

Avec :

\[\vec{OB} \begin{pmatrix} r_2-r_1 \\ O \end{pmatrix} \\ \vec{BD} \begin{pmatrix} (r_1+r_{3_{min}})\cos\left(\frac{5\pi}{6}\right) \\ (r_1+r_{3_{min}})\sin\left(\frac{5\pi}{6}\right) \end{pmatrix} \\ \vec{DE} \begin{pmatrix} r_{3_{min}}\cos(\alpha) \\ r_{3_{min}}\sin(\alpha) \end{pmatrix}\]

Ce qui donne :

\[\vec{OE} \begin{pmatrix} r_2-r_1+(r_1+r_{3_{min}})\cos\left(\frac{5\pi}{6}\right) +r_{3_{min}}\cos(\alpha) \\ (r_1+r_{3_{min}})\sin\left(\frac{5\pi}{6}\right)+r_{3_{min}}\sin(\alpha) \end{pmatrix}\]

On peut alors poser le système d’équations suivant, avec deux inconnues, $\alpha$ et $r_{3_{min}}$ :

\[\begin{cases} r_2\cos(\alpha)=r_2-r_1+(r_1+r_{3_{min}})\cos\left(\frac{5\pi}{6}\right) +r_{3_{min}}\cos(\alpha) \\ r_2\sin(\alpha)=(r_1+r_{3_{min}})\sin\left(\frac{5\pi}{6}\right) +r_{3_{min}}\sin(\alpha) \end{cases} \\ \Leftrightarrow \begin{cases} (r_2-r_{3_{min}})\cos(\alpha)=r_2-r_1-\frac{(r_1+r_{3_{min}})\sqrt{3}}{2} \\ (r_2-r_{3_{min}})\sin(\alpha)=\frac{r_1+r_{3_{min}}}{2} \end{cases} \\ \Leftrightarrow \begin{cases} \left((r_2-r_{3_{min}})\cos(\alpha)\right)^2=\left(r_2-r_1 -\frac{(r_1+r_{3_{min}})\sqrt{3}}{2}\right)^2 \\ \left((r_2-r_{3_{min}})\sin(\alpha)\right)^2 =\left(\frac{r_1+r_{3_{min}}}{2}\right)^2 \end{cases}\]

En additionnant les deux équations, on obtient :

\[(r_2-r_{3_{min}})^2\left(\cos^2(\alpha)+\sin^2(\alpha)\right) = \left(r_2-r_1-\frac{(r_1+r_{3_{min}})\sqrt{3}}{2}\right)^2 + \left(\frac{r_1+r_{3_{min}}}{2}\right)^2 \\ \Leftrightarrow (r_2-r_{3_{min}})^2 = \left(r_2-r_1-\frac{(r_1+r_{3_{min}})\sqrt{3}}{2}\right)^2 + \left(\frac{r_1+r_{3_{min}}}{2}\right)^2\]

Nous sommes parvenu à éliminer $\alpha$ de l’équation.

Avec un peu d’aide pour la résolution, on obtient :

\[r_{3_{min}} =\frac{(2+\sqrt{3})r_1(r_2-r_1)}{(2+\sqrt{3})r_1+(2-\sqrt{3})r_2}\]

Nous sommes à présent en mesure d’exprimer la contrainte $r_{3_{min}}$ en fonction des rayons $r_1$ et $r_2$.

Les points

À présent que nous avons définis les rayons des trois portions de cercles constituant une goutte, $r_1$, $r_2$et $r_3$, nous allons déterminer les coordonnées des points nécessaires au tracé de celle-ci.

Nous nous concentrerons ici sur la goutte violette, telle qu’annotée sur la Figure 3.

A

Le point $A$, départ de la tête se définit simplement à l’aide du rayon $r2$ et de l’angle $\theta$ :

\[A \begin{pmatrix} r_2\cos(\theta) \\ r_2\sin(\theta) \end{pmatrix}\]

B

De la même manière, $B$, centre de l’arc de cercle constituant la tête, se définit comme suit :

\[B \begin{pmatrix} (r_2-r_1)\cos(\theta) \\ (r_2-r_1)\sin(\theta) \end{pmatrix} \Leftrightarrow B \begin{pmatrix} x_B \\ y_B \end{pmatrix}\]

C

Les coordonnées du point $C$, fin de la tête et départ du ventre, sont également les coordonnées du vecteur $\vec{OC}$. En posant $\vec{OC}=\vec{OB}+\vec{BC}$, on obtient :

\[C \begin{pmatrix} x_B+r_1\cos(\theta + \frac{5\pi}{6}) \\ y_B+r_1\sin(\theta + \frac{5\pi}{6}) \end{pmatrix}\]

D

On peut procéder de façon similaire pour le point $D$, centre de l’arc de cercle constituant le ventre. En posant $\vec{OD}=\vec{OB}+\vec{BD}$ on obtient :

\[D \begin{pmatrix} x_B+(r_1+r_3)\cos(\theta + \frac{5\pi}{6}) \\ y_B+(r_1+r_3)\sin(\theta + \frac{5\pi}{6}) \end{pmatrix}\]

E

Déterminer les coordonnées du point $E$ s’avère légèrement plus complexe. Il s’agit de trouver les coordonnées de l’un des points d’intersections entre les cercles $C_2$ et $C_3$.

Figure 6. Calcul des coordonnées du point E

J’ai choisi d’introduire le cercle $C_3'$, symétrique du cercle $C_3$ par rapport à la droite $(EE')$, avec $E$ et $E'$, points d’intersection entre les cercles $C_2$ et $C_3$.

Le cercle $C_3'$ n’est pas indispensable, mais il fournira un support visuel plus accessible pour dérouler la résolution des coordonnées du point $E$.

Soient ^[2] :

\[\begin{cases} a = \overline{ID'} = -\overline{ID} \\ b = \overline{OI} \\ h = \overline{IE} = -\overline{IE'} \\ d = \overline{OD'} = a + b \end{cases}\]

$d$ est la distance entre les points $O$ et $D'$, respectivement centres des cercles $C_2$ et $C_3'$.

On a donc :

\[d = \sqrt{(x_D'-x_O)^2+(y_D'-y_O)^2}\]

$O$ étant l’origine de notre référentiel, nous sommes en réalité dans le cas particulier où $x_D'-x_O = x_D'$ et $y_D'-y_O = y_D'$.

$OEI$et $D'EI$ étant des triangles rectangles, grâce à ce bon vieux Pythagore on peut poser :

\[\begin{cases} a^2 + h^2 = r_3^2 \\ b^2 + h^2 = r_2^2 \end{cases}\]

En soustrayant les deux équations, on obtient :

\[a^2 - b^2 = r_3^2 - r_2^2 \\ \Leftrightarrow a^2 - (d-a)^2 = r_3^2 - r_2^2 \\ \Leftrightarrow a^2 - d^2 +2ad -a^2 = r_3^2 - r_2^2 \\ \Leftrightarrow a = \frac{r_3^2 - r_2^2 + d^2}{2d}\]

À présent que $a$ est connu, reprenons la première équation du système pour déterminer $h$ :

\[h = \sqrt{r_3^2 - a^2}\]

Cherchons à présent à calculer les coordonnées du point $I$.

Figure 7. Application du théorème de Thalès

En invoquant cette fois notre vieux pote Thalès, on peut poser :

\[\frac{\overline{ID'}}{\overline{OD'}} = \frac{\overline{QD'}}{\overline{PD'}} = \frac{\overline{IQ}}{\overline{OP}} \\ \Leftrightarrow \frac{a}{d} = \frac{x_D' - x_I}{x_D' - x_O} = \frac{y_D' - y_I}{y_D' - y_O} \\ \Leftrightarrow \frac{a}{d} = \frac{x_D' - x_I}{x_D'-x_O} = \frac{y_D' - y_I}{y_D'-y_O}\]

Ce qui donne :

\[I \begin{pmatrix} x_D' - (x_D'-x_O) \frac{a}{d} \\ y_D' - (y_D'-y_O) \frac{a}{d} \end{pmatrix}\]

On remarque sur la Figure 7 que le triangle $IER$ est une version modèle réduit du triangle $ID'Q$, orientée de -90° par rapport au point $I$ (un mathématicien parlerait plutôt d’une combinaison de rotation plane et d’homothétie).

Faisons à nouveau appel à Thalès et posons ^[3] :

\[\frac{\overline{IE}}{\overline{ID'}} = \frac{\overline{RE}}{\overline{QD'}} = \frac{\overline{IR}}{\overline{IQ}} \\ \Leftrightarrow \frac{h}{a} = \frac{y_E - y_I}{x_D' - x_I} = \frac{x_E - x_I}{y_D' - y_I}\]

On peut alors calculer les coordonnées du point $E$ :

\[E \begin{pmatrix} (y_D' - y_I) \frac{h}{a} + x_I \\ (x_D' - x_I) \frac{h}{a} + y_I \end{pmatrix}\]

il existe une méthode sans doute plus simple pour calculer les points d’intersection entre deux cercles, à partir des équations de ceux-ci. Mais la méthode employée ici a le mérite de permettre de calculer explicitement, et sans ambigüité les coordonnées du seul point d’intersection qui nous intéresse, le point $E$.

Comme évoqué plus tôt, le cercle $C_3'$ a été introduit uniquement pour fournir un support visuel plus clair et ainsi simplifier la résolution du problème. Toutes les équations établies pour calculer les coordonnées du point $E$ restent valables si on y substitue $D$ à $D'$ en travaillant directement avec le cercle $C_3$.

En attendant de prouver ces dires au travers de l’implémentation à venir, avançons le résultat suivant :

\[E \begin{pmatrix} (y_D - y_I) \frac{h}{a} + x_I \\ (x_D - x_I) \frac{h}{a} + y_I \end{pmatrix}\]

avec :

\[\begin{cases} x_I = x_D - (x_D - x_O) \frac{a}{d} \\ y_I = y_D - (y_D - y_O) \frac{a}{d} \\ h = \sqrt{r_3^2 - a^2} \\ a = \frac{r_3^2 - r_2^2 + d^2}{2d} \\ d = \sqrt{(x_D-x_O)^2+(y_D-y_O)^2} \end{cases}\]

Conclusion

Nous avons à présent tous les éléments nécessaires au tracé d’une première goutte du triskell. Pour tracer les autres, il suffit d’appliquer les même calculs, mais avec un angle $\theta$ différent.

On a un angle de 120° entre deux gouttes du triskell. Si le tracé de la première est calculé avec un angle $\theta$, le tracé de la deuxième sera calculé avec $\theta + \frac{2\pi}{3}$ et enfin la troisième avec $\theta + \frac{4\pi}{3}$.

Nous verrons tout ceci dans un second article qui s’attardera sur les détails d’implémentation avec Vue.js.

1. nouveau dans le sens de premier, et non remplaçant d’une précédente version.

2. Pour ceux qui, comme moi, l’auraient oublié, la barre horizontale placée au dessus des couples de lettres désigne une mesure algébrique

3. On est d’accord, ça manque d’une démonstration sérieuse…

Nouveau blog

Wed, 23 Aug 2017 00:00:00 +0000

Si à 40 ans, tu n’as pas ton blog, tu as raté ta vie…

— « bullshit artist » français bien connu
(propos adaptés)

Même si j’ai encore de nombreuses quelques années devant moi avant d’atteindre cet âge respectable, j’ai ressenti le besoin de rejoindre le mouvement entamé par de nombreux développeurs il y a déjà un moment, mais qui semble profiter d’un retour en grâce ces derniers temps. Je dois bien aussi avouer que la procrastination — terrible fléau — me fait démarrer après tout le monde.

Je ne sais pas qui lira ce blog… Ou plutôt si, je connais déjà très bien au moins un de mes futurs lecteurs. J’écris ce blog en partie pour mon moi du futur qui me sera, j’espère, très reconnaissant de retrouver consigné ici quelques précieuses anecdotes techniques sur lesquels mon moi du passé — ou d’un futur moins futuriste — se sera arraché les cheveux.

Schizophrénie temporelle mise à part, ma démarche est clairement très égoïste. Ce blog est destiné à recueillir, en vrac, de la documentation, des didacticiels ou de simples tuyaux, le tout sur des sujets touchant essentiellement à la programation ou au développement logiciel en général. Mais si le contenu d’une future publication trouve une utilité quelconque auprès d’un lecteur tiers passant par là, tant mieux !

Évidemment, s’agissant d’un blog personnel, je n’exclus pas d’adapter selon mon bon vouloir la ligne éditoriale. Tout dépendra de l’humeur de mon moi rédacteur du futur.

Bon allez ! C’est pas tout ça. Je retourne à l’écriture d’un vrai premier article intéressant (?).

À bientôt !

1	Supprime les structures de données MBR et GPT du disque `/dev/sda`.
2	Informe le système d’exploitation des changements apportés aux tables de partitions.

1	Nom donné au groupe de volumes : « `vgmain` » (🤷‍♂️).
2	Chemin des périphériques blocs à ajouter au groupe de volumes (ici, une seule partition).

1	Nom donné au volume logique : « `root` ».
2	Taille du volume logique : `50 Gio`.

1	Nom donné au volume logique : « `swap` ».
2	Taille du volume logique : `2 Gio`.

1	Nom donné au volume logique : « `crypt` ».
2	Le volume logique occupera 100% de l’espace disponible.

JL

Auto-hébergement (1/n) – la machine 🖥️

Le choix de la machine

Préparation avant installation

Ajout d’un second SSD

Mise à jour du firmware

Prochainement…

Chiffrement transparent des données utilisateurs avec LUKS/dm-crypt 🔐

Préparatifs avant installation

Installation d’Ubuntu 20.04

Avant de redémarrer !

Démarrage

Et au final, content ?

Références

Démarrer un projet basé sur Ruby 💎

RVM (Ruby Version Manager)

Installation

Quelques commandes utiles

Gestion des dépendances

Démarrer un nouveau projet

Rétro-conception d’un logo

Le dessin technique

Un peu de maths…

La tête

Le dos

Le ventre

Le cas \(r_{3_{min}}\)

Les points

A

B

C

D

E

Conclusion

Nouveau blog

Auto-hébergement (1/n) – la machine 🖥️