Un mémo sur la mise en place d’un stockake ZFS pour l’hébergement des sauvegardes d’un Proxmox Backup Server.
L’objectif premier était de concevoir une architecture de stockage à la fois performante, résiliente et facile à maintenir.

Le serveur à ma disposition dispose de 12 disques HDD de 8 To (7.3 To nets) et d’un RAID1 pour le système.

NB : Cet article se concentre exclusivement sur la configuration de ZFS. Il ne couvre pas l’intégration dans proxmox, ni les fonctionnalités avancées telles que les politiques de rétention (Prune), la collecte des données obsolètes (Garbage Collection), ou d’autres options spécifiques à PBS.

Pourquoi ZFS et RAIDZ2 ?

ZFS est un système de fichiers avec comme fonctions :

• Protection contre la corruption de données
• Compression native
• Snapshots incrémentaux
• Et une gestion avancée des volumes et disques.

RAIDZ2 est l’équivalent du RAID6 : il permet de tolérer la perte de deux disques par vdev sans perte de données.

Architecture retenue

Configuration :

• 2 vdevs de 5 disques en RAIDZ2
• 2 disques en spare

• Détails :
  • Disques actifs : 10 (5+5 + 2×parité RAIDZ2)
  • Disques spare : 2 (remplacement automatique en cas de panne)
  • Tolérance aux pannes : jusqu’à 2 disques HS par vdev
  • Capacité utilisable : environ 58.4 To nets (8 disques × 7.3 To)

Pourquoi deux vdevs RAIDZ2 au lieu d’un seul ?

Choisir 2 vdevs RAIDZ2 au lieu d’un seul vdev de 12 disques RAIDZ2 présente plusieurs avantages :

• Performance accrue : les deux vdevs fonctionnent en parallèle → plus d’IOPS.
• Resilvering plus rapide : une reconstruction de disque touche seulement un vdev (5 disques), pas 12.
• Risque réduit : 3 disques HS ne sont pas fatal si répartis sur les 2 vdevs.
• Évolutivité : possibilité d’ajouter un 3e vdev plus tard sans casser le pool.

Création du pool ZFS avec 2 disques en spares

• Création du pool :

zpool create -o ashift=12 -o autotrim=on \
  -O compression=lz4 -O atime=off -O xattr=sa -O acltype=posixacl \
  pbs_pool \
  raidz2 /dev/sd[a-e] \
  raidz2 /dev/sd[f-j] \
  spare /dev/sdk /dev/sdl

NAME       SIZE  ALLOC   FREE  CKPOINT  EXPANDSZ   FRAG    CAP  DEDUP    HEALTH  ALTROOT
pbs_pool  72.8T  1.37M  72.7T        -         -     0%     0%  1.00x    ONLINE  -

zpool status

  pool: pbs_pool
 state: ONLINE
config:

	NAME        STATE     READ WRITE CKSUM
	pbs_pool    ONLINE       0     0     0
	  raidz2-0  ONLINE       0     0     0
	    sda     ONLINE       0     0     0
	    sdb     ONLINE       0     0     0
	    sdc     ONLINE       0     0     0
	    sdd     ONLINE       0     0     0
	    sde     ONLINE       0     0     0
	  raidz2-1  ONLINE       0     0     0
	    sdf     ONLINE       0     0     0
	    sdg     ONLINE       0     0     0
	    sdh     ONLINE       0     0     0
	    sdi     ONLINE       0     0     0
	    sdj     ONLINE       0     0     0
	spares
	  sdk       AVAIL   
	  sdl       AVAIL   

errors: No known data errors

• Création du dataset pour PBS :

zfs create -o mountpoint=/mnt/datastore/pbs pbs_pool/pbs

Bonus : Resilvering (reconstruction de disque)

Le resilvering est le processus par lequel ZFS reconstruit les données d’un disque défaillant ou remplacé dans un pool RAIDZ, en utilisant les autres disques et les données redondantes (parité).

C’est l’équivalent du rebuild dans les RAID classiques.

Contrairement aux RAID matériels, ZFS ne recopie pas tout le disque, mais uniquement les blocs réellement utilisés, ce qui rend le resilvering souvent plus rapide et plus sûr.

Ressources

• ZFS RAIDZ2 Explained – OpenZFS Docs
• Documentation officielle Proxmox Backup Server

Un petit mémo pour expliquer comment forcer l’utilisation d’un miroir local lors de l’installation de Ceph sur Proxmox.

Par défaut, que ce soit via l’interface web de Proxmox ou la commande pveceph, l’installation de Ceph s’appuie sur le script Perl pveceph.pm, qui impose l’utilisation du dépôt officiel https://enterprise.proxmox.com ou http://download.proxmox.com.

Cela pose problème lorsqu’on souhaite utiliser un miroir local, par exemple avec Proxmox Offline Mirror. En effet, même si un miroir local est disponible sur le système, il ne sera pas pris en compte : le script pveceph.pm remplace automatiquement les dépôts configurés par ceux qu’il contient en dur.

Configurer et utiliser un dépôt local Ceph pour Proxmox

Comme indiqué en début d’article, les urls des dépots sont renseignées dans le script perl pveceph.pm :

grep proxmox.com /usr/share/perl5/PVE/CLI/pveceph.pm
	my $cdn = $enterprise_repo ? 'https://enterprise.proxmox.com' : 'http://download.proxmox.com';

• Changer l’url http://download.proxmox.com par celle du dépôt local (dans mon cas http://mirrors.local) :

sed -i 's/download\.proxmox\.com/mirrors\.local/g' /usr/share/perl5/PVE/CLI/pveceph.pm

sed -i 's/debian\/ceph/ceph\/latest\/ceph/g' /usr/share/perl5/PVE/CLI/pveceph.pm

Installation de Ceph via le dépôt local

• Cliquer dans le menu Ceph de Proxmox pour l’installation :



• Sélectionner la bonne version de Ceph et le dépôt No-Subscription



• Et si tout va bien :



• Sur la capture ci-dessous, l’url du dépôt de Ceph est bien celle du dépôt local :

Un mémo sur comment installer, configurer et intégrer Authelia à Proxmox pour l’authentification unique et à deux facteurs.

Présentation d’Authelia

Authelia est une solution d’authentification et d’autorisation open-source destinée à sécuriser l’accès aux applications web. Elle agit comme un reverse proxy d’authentification centralisé, offrant une gestion avancée des utilisateurs et des stratégies d’accès.
Principales fonctionnalités :

Authentification à deux facteurs (2FA) : Supporte TOTP, Duo, WebAuthn (FIDO2).
Intégration avec OpenID Connect : Permet l’authentification unique (SSO).
Gestion fine des accès : Basée sur les règles configurables (ACL).
Compatibilité avec les reverse proxies : Fonctionne avec Traefik, Nginx, Caddy, etc.
Stockage flexible : Supporte SQLite, PostgreSQL et MySQL pour la gestion des utilisateurs.
Déploiement facile : Disponible via Docker, Kubernetes et installation classique.
Cas d’usage

Sécuriser des services auto-hébergés (GitLab, Nextcloud, Home Assistant…)
Mettre en place un portail SSO centralisé pour plusieurs applications
Renforcer la sécurité des accès avec la double authentification

Informations globales et installation des dépendances nécessaires

Pour le mémo, voici les informations utilisées :

• L’OS du serveur Authelia : Debian 12
• L’installation d’Authelia se fait sans docker
• Pas de serveur SMTP sur Authelia
• nom d’hôtes :
  • Serveur Proxmox : proxmox.local
  • Serveur Authelia : authelia.local
• Utilisateur de test :
  • login: testuser
  • Mot de passe : authelia
• Installation des dépendances nécessaires :

apt install install nginx openssl apt-transport-https curl gnupg -y

Installation de Authelia via le dépôt

• Importez la clé de signature :

curl -fsSL https://apt.authelia.com/organization/signing.asc | sudo gpg --dearmor -o /etc/apt/keyrings/authelia.gpg

echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/authelia.gpg] https://apt.authelia.com/stable/debian/debian all main" | sudo tee /etc/apt/sources.list.d/authelia.list > /dev/null

apt update

apt install authelia -y

Configuration de Authelia

• Configuration de base :
  • Génération d’un certificat et d’une clé privé pour Authelia :

  mkdir -p /etc/authelia/ssl
  cd /etc/authelia/ssl
  authelia crypto pair rsa generate
  

• Création du fichier de configuration (attention, ici j’intègre de suite la partie client de Proxmox ) :

  nano /etc/authelia/configuration.yml

  ---
  # Configuration du serveur Authelia
  server:
    address: "tcp://0.0.0.0:9091/"  # Écoute sur toutes les interfaces sur le port 9091
  
  # Configuration des logs
  log:
    level: debug  # Niveau de log : debug pour plus de détails
  
  # Configuration de la validation d'identité
  identity_validation:
    reset_password:
      jwt_secret: "ba820cfdc0c587eff1a23b96a3896ec7a076c384c09ad10bfc1b74788eea39631a4d9cfa22717645a396f5d45b18d632602e848ecb8c967b7854d5ebc4446b8a"  # Clé secrète pour le JWT utilisé dans la réinitialisation de mot de passe
  
  # Configuration des sessions
  session:
    name: authelia_session  # Nom du cookie de session
    same_site: lax  # Politique SameSite pour le cookie
    expiration: 1h  # Durée de vie de la session
    inactivity: 5m  # Temps d'inactivité avant expiration de la session
    remember_me: 1M  # Durée de la session en mode "Se souvenir de moi"
    secret: "8938ce8b853e74b35c05e0f10a904bd6ce4849d2aed8fb1b23b2916dd70c2af487a9ae5bf9672fa82411a3b171d351c08a0b75aa151939be45427174c26d5d60"  # Clé secrète pour la session
    cookies:
      - domain: "authelia.local"  # Domaine du cookie
        authelia_url: "https://authelia.local"  # URL d'Authelia
        same_site: lax  # Politique SameSite du cookie
  
  # Configuration du contrôle d'accès
  access_control:
    default_policy: deny  # Politique par défaut : refusé
    rules:
      - domain: "authelia.local"  # Domaine protégé
        policy: two_factor  # Exige une authentification à deux facteurs
      - domain: "proxmox.local"  # Domaine protégé
        policy: two_factor  # Exige une authentification à deux facteurs
  
  # Backend d'authentification (fichier YAML)
  authentication_backend:
    file:
      path: "/etc/authelia/users.yml"  # Chemin du fichier contenant les utilisateurs
  
  # Configuration du TOTP (authentification à deux facteurs par application OTP)
  totp:
    issuer: authelia.local  # Émetteur pour les codes OTP
    algorithm: sha256  # Algorithme utilisé pour le TOTP
    digits: 6  # Nombre de chiffres dans le code OTP
    period: 30  # Durée de validité du code en secondes
    skew: 1  # Tolérance de synchronisation en périodes
    secret_size: 32  # Taille du secret généré
  
  # Configuration du fournisseur OpenID Connect
  identity_providers:
    oidc:
      jwks:
        - key: |
            -----BEGIN PRIVATE KEY-----
            (clé privée pour la signature des tokens JWT. Voir plus bas  "Pour générer la clé privé de identity_providers")
            -----END PRIVATE KEY-----
      clients:
        - client_id: proxmox  # Identifiant du client OpenID Connect
          client_name: "proxmox.local"  # Nom du client
          client_secret: "$pbkdf2-sha512$310000$..."  # Secret du client (hashé)
          redirect_uris:
            - https://proxmox.local:8006  # URI de redirection après authentification
          scopes:
            - openid  # Activation du scope OpenID
            - profile  # Activation du scope profil
            - email  # Activation du scope email
          userinfo_signed_response_alg: none  # Réponse des infos utilisateur non signée
          require_pkce: false  # Désactive l'utilisation de PKCE
          authorization_policy: two_factor  # Exige une authentification à deux facteurs
  
  # Configuration du stockage\storage:
    encryption_key: "ae5060901aaf3172cc87b896c92c30961b3734fc9a97be5c1da77b04dd4b754433f5cad3f679140d70ccc1a31743194231be04c5922dba34c275f89ac0bb42ce"  # Clé de chiffrement des données stockées
    local:
      path: "/var/lib/authelia/db.sqlite3"  # Utilisation d'une base de données SQLite pour le stockage local
  
  # Configuration des notifications
  notifier:
    filesystem:
      filename: "/var/log/authelia/notifications.txt"  # Fichier où sont stockées les notifications
  

  • Pour générer la clé privé de identity_providers :

  authelia crypto pair rsa generate

  cat private.pem

• Pour jwt_secret, session.secret et encryption_key :

openssl rand -hex 64

authelia crypto hash generate pbkdf2 --password toto

authelia crypto hash generate --password authelia

nano /etc/authelia/users.yml

users:
  testuser:
    displayname: "Test User"
    password: "$argon2id$v=19$m=32768,t=1,p=8$eUhVT1dQa082YVk2VUhDMQ$E8QI4jHbUBt3EdsU1NFDu4Bq5jObKNx7nBKSn1EYQxk"

authelia validate-config -c /etc/authelia/configuration.yml

Configuration parsed and loaded successfully without errors.

cp /tmp/authelia.service /etc/systemd/system/
systemctl daemon-reload
systemctl enable --now authelia
systemctl status authelia

journalctl -u authelia -f

Configuration du serveur web d’Authelia

Attention, ici c’est une proposition de configuration nginx de base fonctionnelle

• Génération du certificat SSL autosigné :

mkdir -p /etc/nginx/ssl
cd /etc/nginx/ssl
openssl req -x509 -nodes -days 365 -newkey rsa:4096 -keyout authelia.key -out authelia.crt -subj "/CN=authelia.local"
chmod 600 authelia.key authelia.crt

nano /etc/nginx/site-enable/authelia.conf

server {
    listen 443 ssl;
    server_name authelia.local;

    ssl_certificate /etc/nginx/ssl/authelia.crt;
    ssl_certificate_key /etc/nginx/ssl/authelia.key;

    location / {
        proxy_pass http://localhost:9091;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto https;
    }
}

# Redirection HTTP -> HTTPS
server {
    listen 80;
    server_name authelia.local;
    return 301 https://$host$request_uri;
}

nginx -t

systemctl restart nginx

Configuration de la double authentification de Authelia avec TOTP

• Sur le smartphone, installer l’application libre et open-source Aegis Authenticator -> https://f-droid.org/fr/packages/com.beemdevelopment.aegis/
• Sur le PC, ouvrir le navigateur Internet et saisir l’URL du serveur Authelia :



• Cliquer sur « Enregistrer l’appareil » :



• Cliquer sur Ajouter :



• Saisir le mot de passe à usage unique :
  
  • Mais je n’ai pas de serveur SMTP de configurer ???
    Le mot de passe unique, se trouve dans /var/log/authelia/notifications.txt

  cat /var/log/authelia/notifications.txt

  Date: 2025-03-19 10:40:29.407130819 +0100 CET m=+5967.802203980
  Recipient: {testuser testuser@example.com}
  Subject: Confirm your identity
  A ONE-TIME CODE HAS BEEN GENERATED TO COMPLETE A REQUESTED ACTION
  
  Hi testuser,
  
  This notification has been sent to you in order to verify your identity to
  change security details for your account at authelia.local.
  
  Do not share this notification or the content of this notification with anyone.
  
  The following one-time code should only be used in the prompt displayed in your
  browser.
  
  --------------------------------------------------------------------------------
  
  B6LAMWY4
  
  --------------------------------------------------------------------------------
  

Intégration d’Authelia à Proxmox

• Première chose, importer le certificat autosigné d’Authelia dans le magasin de certificat de Proxmox :

scp root@authelia.local:/etc/nginx/ssl/authelia.crt /usr/local/share/ca-certificates/

update-ca-certificates

tester l’authentification sur Proxmox

• Ouvrir Proxmox et sélectionner authelia comme système d’authentification :



• Redirection vers le serveur Authelia, saisir le login et mot de passe :



• La double authentification avec le code temporaire :



• Accepter le consentement :



• Et voilà, l’utilisateur testuser est connecté à Proxmox (évidemment, faudra configurer ses droits) :

Ressources

• Je me suis aidé de ChatGPT, Mistral et Claude, mais aucun des trois n’a été totalement capable de m’aider.
• La documentation officielle : https://github.com/authelia/authelia/tree/master/docs
• Pour vérifier la configuration d’Authelia : https://www.authelia.com/reference/cli/authelia/authelia_config_validate/
• Les commandes de chiffrement : https://www.authelia.com/reference/cli/authelia/authelia_crypto/
• L’intégration dans Proxmox d’Authelia : https://www.authelia.com/integration/openid-connect/proxmox/
• Pour le choix de l’application : https://www.authelia.com/reference/integrations/time-based-one-time-password-apps/
• Pour récupérer le code sans serveur SMTP : https://www.simplehomelab.com/docker-authelia-tutorial/
• Pour installer Authelia via les dépôts : https://blog.cyril.by/en/software/single-sign-on/installing-authelia-for-sso-all-in-one-guide

Un petit article sur comment regarder une vidéo Youtube sans pub dans son terminal avec YT-X.

Sur le blog, un autre lecteur permettant de lire YouTube depuis le terminal a déjà été présenté : https://memo-linux.com/mps-youtube-regarder-youtube-dans-le-terminal/

Description de YT-X

Caractéristiques principales

• Téléchargement polyvalent :
  • Téléchargez des vidéos individuelles ou des playlists entières.
  • Prend en charge plusieurs formats (audio et vidéo) comme MP4, MKV, MP3, etc.
  • Sélectionnez des qualités spécifiques, allant de 360p à 4K, selon vos besoins.
• Extraction audio :
  • Extrayez directement l’audio en formats populaires tels que MP3, AAC ou OPUS.
• Gestion des métadonnées
  • Ajoutez automatiquement des métadonnées comme le titre, l’artiste ou l’album.
  • Idéal pour organiser des bibliothèques multimédia.
• Personnalisation :
  • Configurez le chemin de téléchargement, la qualité par défaut, et plus encore via un fichier config.json.
  • Support pour l’utilisation de proxies pour contourner des restrictions géographiques.
• Intégration de yt-dlp :
  • Bénéficie de la puissance de yt-dlp, un outil performant pour le téléchargement de vidéos.
  • Compatible avec une grande variété de plateformes en plus de YouTube.
• Optimisation pour les utilisateurs avancés :
  • Options pour le téléchargement en masse via des fichiers d’URL.
  • Contrôle total sur les paramètres vidéo et audio grâce aux options de la ligne de commande.

Avantages de YT-X

• Simplicité d’utilisation : une interface en ligne de commande claire et intuitive.
• Flexibilité : prend en charge divers cas d’utilisation, du téléchargement rapide à la gestion avancée.
• Open Source : entièrement gratuit et modifiable pour répondre à vos besoins spécifiques.

Cas d’utilisation courants

• Créer une collection de vidéos ou musiques à regarder/habituer hors ligne.
• Organiser les fichiers téléchargés avec des noms et des métadonnées propres.
• Extraire des bandes sonores pour des projets créatifs ou pour une utilisation personnelle.
• Télécharger du contenu géo-bloqué grâce au support de proxies.

Pré-requis avant installation de YT-X

• Installer les dépendances :
  • Sous Ubuntu :

  sudo apt install yt-dlp fzf jq curl yt-dlp fzf mpv ffmpeg -y

• Sous Archlinux :

sudo pacman -S yt-dlp fzf jq curl yt-dlp fzf mpv ffmpeg

Installation de YT-X

• Exécuter la commande suivante :

curl -sL "https://raw.githubusercontent.com/Benexl/yt-x/refs/tags/0.3.0/yt-x" -o ~/.local/bin/yt-x && chmod +x ~/.local/bin/yt-x

Utilisation de YT-X

Pour l’exemple, je vais utiliser la chaine Youtube d’Adrian Linuxtricks.

• Lancer yt-x :

yt-x

Ressource

• https://github.com/Benexl/yt-x?tab=readme-ov-file#usage

Un mémo sur la mise en place du module de sécurité pam_faillock sur Debian 12. Ce module permet de verrouiller temporairement un compte utilisateur connu du système après plusieurs tentatives de connexion infructueuses via ssh.

Prérequis

• Une machine tournant sous Debian 12 (Bookworm).
• Un accès root ou des privilèges sudo.
• Une compréhension de base des fichiers PAM (Pluggable Authentication Modules).

Étape 1 : Installer les paquets nécessaires

pam_faillock est inclus dans le paquet libpam-modules, qui est installé par défaut sur Debian 12.

Étape 2 : Configurer pam_faillock

• Modifier le fichier PAM de gestion des connexions locales :
  • Éditer le fichier /etc/pam.d/common-auth :

    auth    required                        pam_faillock.so preauth
    auth    [success=1 default=ignore]      pam_unix.so nullok
    auth    [default=die]                   pam_faillock.so authfail
    auth    sufficient                      pam_faillock.so authsucc
    auth    requisite                       pam_deny.so
    auth    required                        pam_permit.so
    

  

Éditer le fichier /etc/pam.d/common-account :

account required                        pam_faillock.so

Étape 3 : Tester la configuration

• Vérifier les logs :
  • Les échecs de connexion sont enregistrés dans les journaux système :

  sudo journalctl -xe | grep pam_faillock

• Simuler des échecs de connexion :
  • Tester plusieurs fois des connexions avec un mauvais mot de passe :
    
    • Vérifier les comptes verrouillés :
      • Utilisez la commande suivante pour lister les utilisateurs verrouillés :

      sudo faillock

      

    • Pour réinitialiser les tentatives d’échec d’un utilisateur spécifique :

    sudo faillock --reset --user utilisateur

Trippy est un outil de diadnostique réseaux sous licence Apache 2 combinant les fonctionnalités de traceroute et de ping dans une interface en mode texte (TUI) afin d’aider les administrateurs systèmes et réseaux.

• Trippy propose plusieurs options personnalisables pour l’analyse réseau :
  • Mode interactif avec une carte et des graphiques :
    • Trippy affiche un aperçu visuel dans le terminal. Cela inclut les sauts réseau et leurs temps de réponse.
  • Personnalisation des paramètres de traçage :
    • Définir le nombre de paquets envoyés.
    • Ajuster l’intervalle entre les requêtes.
  • Statistiques de confidentialité des sauts : il est possible d’anonymiser certaines informations des sauts pour protéger la confidentialité des adresses IP.
  • Génération de rapports : Trippy peut exporter des résultats pour analyse ultérieure.

Installation de Trippy

• Exemple d’installation de Trippy :
  • Ubuntu :

  sudo add-apt-repository ppa:fujiapple/trippy
  sudo apt update && sudo apt install trippy
  

• ArchLinux :

sudo pacman -S trippy

apt install cargo -y

cargo install trippy

docker run -it fujiapple/trippy

Utilisation de Trippy

• Commande de base :
  • Par exemple, pour tracer la route jusqu’à google.com :

  trip google.com

trippy --protocol tcp google.com

trip --max-flows 15 example.com

trip --protocol tcp --target-port 80 example.com

Documentation complète de trippy

• Pour plus d’informations sur l’outil trippy : https://github.com/fujiapple852/trippy?tab=readme-ov-file#features

Un mémo sur comment utiliser la commande proxmox-offline-mirror pour créer un miroir local pour les distributions Debian et Ubuntu.

Pour la création d’un miroir local Pour Proxmox, voir cet article : https://memo-linux.com/proxmox-offline-mirror-creer-un-miroir-local-pour-proxmox/

Créer un miroir local Debian

Pour la création d’un miroir local pour la distribution Debian, rien de compliqué car c’est intégré à la commande proxmox-offline-mirror :

proxmox-offline-mirror setup

• Select Action: dd new mirror entry
• Guided Setup ([yes]): yes
• Select distro to mirror : 4
• Select release : 0 (pour Bookworm)
• Select repository variant :
  • 0) Main repository
  • 1) Security
  • 2) Updates
  • 3) Backports
  • 4) Debug Information

  Dans mon cas, j’ai éxécuté la commande proxmox-offline-mirror setup 3 fois pour avoir les 3 miroirs : Main repository, Security et Updates.

• Enter repository components : main contrib (les dépots non-free c’est à vous de choisir)
• Configure filters for Debian mirror bookworm / main : – (pas de filtres dans mon cas)
• Enter mirror ID :
  • debian_bookworm_main
  • debian_bookworm_security
  • debian_bookworm_updates
• Enter (absolute) base path where mirrored repositories will be stored : /srv/mirrors/debian/ (à adapter)
• Should already mirrored files be re-verified when updating the mirror? : yes
• Should newly written files be written using FSYNC to ensure crash-consistency? : yes
• Pour finir, Select Action : Quit

• Pour automatiser la création et la mise à jour du miroir Debian, voici le script :

nano /usr/local/bin/sync-debian.sh

#!/bin/bash
export ALL_PROXY="http://proxyx.local:PORT"

mirror_dir="/srv/mirrors/debian"
symlink_dir="/srv/mirrors/debian/latest"

proxmox-offline-mirror mirror snapshot create --config '/etc/proxmox-offline-mirror.cfg' 'debian_bookworm_main'
proxmox-offline-mirror mirror snapshot create --config '/etc/proxmox-offline-mirror.cfg' 'debian_bookworm_updates'
proxmox-offline-mirror mirror snapshot create --config '/etc/proxmox-offline-mirror.cfg' 'debian_bookworm_security'

if [ $? -eq 0 ]; then
    for dir in "${mirror_dir}"/*; do
        if [ -d "$dir" ]; then
            dir_name=$(basename "$dir")
            if [[ "$dir_name" != "latest" && "$dir_name" != "lost+found" ]]; then
                latest_subdir=$(ls -td "$dir"/*/ | head -n 1)
                if [ -n "$latest_subdir" ]; then
                    latest_subdir_name=$(basename "$latest_subdir")
                    if [ -e "${symlink_dir}/${dir_name}" ]; then
                        rm -f "${symlink_dir}/${dir_name}"
                    fi
                    ln -s "$latest_subdir" "${symlink_dir}/${dir_name}"
                fi
            fi
        fi
    done
    echo "Done on ${symlink_dir}."
else
    echo "Error."
fi

chmod +x /usr/local/bin/sync-debian.sh

sync-debian.sh

crontab -e

0 2 * * * /usr/local/bin/sync-debian.sh

Créer un miroir local Ubuntu

A la date de publication de l’article, la commande proxmox-offline-mirror setup n’est pas opérationnelle pour créer un miroir local pour la distribution Ubuntu.

Ici, je choisis la distribution Ubuntu 24.04 LTS Noble.

• Préparation du miroir Ubuntu Noble :
  • Création des répertoires pour le miroir :

  mkdir -p /srv/mirrors/ubuntu/noble/{ubuntu_noble_main,ubuntu_noble_updates,ubuntu_noble_security,latest}

  mkdir -p /srv/mirrors/ubuntu/noble/.pool

• Téléchargement de la clé ubuntu :

wget -qO  /usr/share/keyrings/ubuntu-archive-keyring.gpg "https://keyserver.ubuntu.com/pks/lookup?op=get&search=0xF6ECB3762474EDA9D21B7022871920D1991BC93C"

nano /etc/proxmox-offline-mirror.cfg

mirror: ubuntu_noble_main
        architectures amd64
        architectures all
        base-dir /srv/mirrors/ubuntu/noble
        ignore-errors false
        key-path /usr/share/keyrings/ubuntu-archive-keyring.gpg
        repository deb https://fr.archive.ubuntu.com/ubuntu noble main restricted universe multiverse
        sync true
        verify true

mirror: ubuntu_noble_updates
        architectures amd64
        architectures all
        base-dir /srv/mirrors/ubuntu/noble
        ignore-errors false
        key-path /usr/share/keyrings/ubuntu-archive-keyring.gpg
        repository deb https://fr.archive.ubuntu.com/ubuntu noble-updates main restricted universe multiverse
        sync true
        verify true

mirror: ubuntu_noble_security
        architectures amd64
        architectures all
        base-dir /srv/mirrors/ubuntu/noble
        ignore-errors false
        key-path /usr/share/keyrings/ubuntu-archive-keyring.gpg
        repository deb https://fr.archive.ubuntu.com/ubuntu noble-security main restricted universe multiverse
        sync true
        verify true

nano /usr/local/bin/sync-ubuntu.sh

#!/bin/bash

export ALL_PROXY="http://proxy.local:PORT"

mirror_dir="/srv/mirrors/ubuntu/noble"
symlink_dir="/srv/mirrors/ubuntu/noble/latest"

proxmox-offline-mirror mirror snapshot create --config '/etc/proxmox-offline-mirror.cfg' 'ubuntu_noble_main'
proxmox-offline-mirror mirror snapshot create --config '/etc/proxmox-offline-mirror.cfg' 'ubuntu_noble_updates'
proxmox-offline-mirror mirror snapshot create --config '/etc/proxmox-offline-mirror.cfg' 'ubuntu_noble_security'

if [ $? -eq 0 ]; then
    for dir in "${mirror_dir}"/*; do
        if [ -d "$dir" ]; then
            dir_name=$(basename "$dir")
            if [[ "$dir_name" != "latest" && "$dir_name" != "lost+found" ]]; then
                latest_subdir=$(ls -td "$dir"/*/ | head -n 1)
                if [ -n "$latest_subdir" ]; then
                    latest_subdir_name=$(basename "$latest_subdir")
                    if [ -e "${symlink_dir}/${dir_name}" ]; then
                        rm -f "${symlink_dir}/${dir_name}"
                    fi
                    ln -s "$latest_subdir" "${symlink_dir}/${dir_name}"
                fi
            fi
        fi
    done
    echo "Done on ${symlink_dir}."
else
    echo "Error."
fi

chmod +x /usr/local/bin/sync-ubuntu.sh

sync-ubuntu.sh

cat /etc/apt/sources.list

# Ubuntu sources have moved to /etc/apt/sources.list.d/ubuntu.sources

nano /etc/apt/sources.list.d/ubuntu.sources

Types: deb
URIs: http://mirrors.local/ubuntu/noble/latest/ubuntu_noble_main
Suites: noble
Components: main restricted universe multiverse
Signed-By: /usr/share/keyrings/ubuntu-archive-keyring.gpg

Types: deb
URIs: http://mirrors.local/ubuntu/noble/latest/ubuntu_noble_security
Suites: noble-security
Components: main restricted universe multiverse
Signed-By: /usr/share/keyrings/ubuntu-archive-keyring.gpg

Types: deb
URIs: http://mirrors.local/ubuntu/noble/latest/ubuntu_noble_updates
Suites: noble-updates
Components: main universe restricted multiverse
Signed-By: /usr/share/keyrings/ubuntu-archive-keyring.gpg

apt update

Hit:1 http://mirrors.local/ubuntu/noble/latest/ubuntu_noble_main noble InRelease
Hit:2 http://mirrors.local/ubuntu/noble/latest/ubuntu_noble_security noble-security InRelease
Hit:3 http://mirrors.local/ubuntu/noble/latest/ubuntu_noble_updates noble-updates InRelease
Reading package lists... Done
Building dependency tree... Done
Reading state information... Done
89 packages can be upgraded. Run 'apt list --upgradable' to see them

crontab -e

0 3 * * * /usr/local/bin/sync-ubuntu.sh

Un mémo sur comment créer un serveur miroir local pour Proxmox avec proxmox-offline-mirror sous Debian.

Installer proxmox-offline-mirror sur Debian via apt

• Ajouter le dépôt suivant :

echo "deb http://download.proxmox.com/debian/pbs-client bookworm main" > /etc/apt/sources.list.d/pbs-client.list

wget https://enterprise.proxmox.com/debian/proxmox-release-bookworm.gpg   -O /etc/apt/trusted.gpg.d/proxmox-release-bookworm.gpg

apt update

apt install proxmox-offline-mirror

Configurer proxmox-offline-mirror pour le dépôt Proxmox

• Exécuter la commande :

  proxmox-offline-mirror setup

  • Pour ajouter un nouveau miroir, choisir 0 :
  • Pour être guidé, répondre « yes » :
  • Choisir le dépôt Proxmox ve :
  • Choisir la version Bookworm :
  • Choisir la variante « No-Subscription repository » :
  • Pour la question suivante « Should missing Debian mirrors for the selected product be auto-added » ayant déjà mon propre miroir local Debian, je répond non :
  • Pour l’ID laisser pve_bookworm_no_subscription :
  • Entrer le chemin complet du répertoire pour le dépôt, dans mon cas /srv/mirrors/proxmox/ :
  • Revérifier ou pas les dépôts une fois mis à jour, dans mon cas je répond : yes
  • En cas de plantage, utiliser ou pas FSYNC, je répond : yes
  • Retour au menu, choisir 3 pour quitter :

  

  • Une fois que la configuration est terminée, éxécuter la commande :

    proxmox-offline-mirror mirror snapshot create --config '/etc/proxmox-offline-mirror.cfg' 'pve_bookworm_no_subscription'

    • Si l’accès au dépôt se fait via un proxy, exporter la variable d’environnement PROXY_ALL avant l’éxécution de la synchro:

    export PROXY_ALL="http://proxy.domaine.tld:PORT/"
    

  

Ajouter un nouveau dépôt

Ici le dépôt ajouté sera celui de Ceph.

• Exécuter la commande :

proxmox-offline-mirror setup

Une fois le dépôt ajouté, créer le snapshot du miroir :

proxmox-offline-mirror mirror snapshot create --config '/etc/proxmox-offline-mirror.cfg' 'ceph_reef_bookworm'

Configurer le serveur web

Pour rappel, dans mon cas le serveur web est déjà installé. J’ajoute simplement une directive location dans mon fichiers de conf.
Ce qui donne :

nano /etc/nginx/sites-available/mirrors

server {
    listen 80;
    server_name mirrors.local;

    root /srv/mirrors;
    index index.html;

    location /debian/ {
        alias /srv/mirrors/debian/;
        autoindex on;
    }

    location /ubuntu/ {
        alias /srv/mirrors/ubuntu/;
        autoindex on;
    }

   location /proxmox/ {
        alias /srv/mirrors/proxmox/;
        autoindex on;
    }

    }

systemctl reload nginx

Créer un chemin statique pour les dépôts Proxmox et Ceph

De base, la commande proxmox-offline-mirror créé pour chaque dépôt un snapshot daté du jour.
Un problèmes majeur :

• Sur chaque noeud Proxmox faudra changer le dépôt comme suit :

deb http://mirrors.local/proxmox/pve_bookworm_no_subscription/2024-12-10T10:20:21Z bookworm pve-no-subscription

Pour obtenir qu’un seul référentiel pour le dépôt :

• Créer le dossier :

mkdir -p /srv/mirrors/proxmox/latest

nano /usr/local/bin/sync-proxmox.sh

#!/bin/bash
export ALL_PROXY="http://proxy.local:PORT"
mirror_dir="/srv/mirrors/proxmox"
symlink_dir="/srv/mirrors/proxmox/latest"
proxmox-offline-mirror mirror snapshot create-all
if [ $? -eq 0 ]; then
    for dir in "${mirror_dir}"/*; do
        if [ -d "$dir" ]; then
            dir_name=$(basename "$dir")
            if [[ "$dir_name" != "latest" && "$dir_name" != "lost+found" ]]; then
                latest_subdir=$(ls -td "$dir"/*/ | head -n 1)
                if [ -n "$latest_subdir" ]; then
                    latest_subdir_name=$(basename "$latest_subdir")
                    if [ -e "${symlink_dir}/${dir_name}" ]; then
                        rm -f "${symlink_dir}/${dir_name}"
                    fi
                    ln -s "$latest_subdir" "${symlink_dir}/${dir_name}"
                fi
            fi
        fi
    done
    echo "Done on ${symlink_dir}."
else
    echo "Error."
fi

Créer une tache cron pour synchroniser le miroir de Proxmox

• Créer une tache cron :

crontab -e

0 4 * * * /usr/local/bin/sync-proxmox.sh

Changer les dépôts sur les noeuds Proxmox

• Editer vos fichiers sources.list et changer les url par celle de votre miroir local :

deb http://mirrors.local/debian bookworm main contrib
deb http://mirrors.local/debian bookworm-updates main contrib
deb http://mirrors.local/debian bookworm-security main contrib

deb http://mirrors.local/proxmox/latest/pve_bookworm_no_subscription bookworm pve-no-subscription
deb http://mirrors.local/proxmox/latest/ceph_reef_bookworm no-subscription

apt update

Nettoyage des snapshots Proxmox et Ceph

• pré-requis : installer le paquet jq :

  apt install jq

• Créer le script :

nano /url/local/bin/clean_proxmox_snapshots.sh

#!/bin/bash

# Variables
MIRRORS=(
    "pve_bookworm_no_subscription"
    "ceph_reef_bookworm"
    "debian_bookworm_main"
    "debian_bookworm_security"
    "debian_bookworm_updates"
    )
MAX_AGE=7  # Durée limite (en jours)

# Fonction pour convertir une date ISO 8601 en timestamp Unix
iso_to_timestamp() {
    date -d "$1" +%s
}

# Nettoyage pour chaque miroir
for MIRROR_NAME in "${MIRRORS[@]}"; do
    echo "Traitement du miroir : $MIRROR_NAME"

    # Liste des snapshots du miroir
    SNAPSHOTS=$(proxmox-offline-mirror mirror snapshot list "$MIRROR_NAME" --output-format json | \
    jq -r ".\"$MIRROR_NAME\"[]")

    if [[ -z "$SNAPSHOTS" ]]; then
        echo "Aucun snapshot à supprimer pour le miroir : $MIRROR_NAME"
    else
        echo "Suppression des snapshots suivants pour $MIRROR_NAME :"
        for SNAPSHOT in $SNAPSHOTS; do
            SNAPSHOT_TIMESTAMP=$(iso_to_timestamp "$SNAPSHOT")
            CURRENT_TIMESTAMP=$(date +%s)
            AGE_DAYS=$(( (CURRENT_TIMESTAMP - SNAPSHOT_TIMESTAMP) / 86400 ))

            if (( AGE_DAYS > MAX_AGE )); then
                proxmox-offline-mirror mirror snapshot remove "$MIRROR_NAME" "$SNAPSHOT"
                echo "Snapshot supprimé : $SNAPSHOT"
            fi
        done

        # Garbage collection
        echo "Exécution de garbage collection (GC) pour le miroir : $MIRROR_NAME"
        proxmox-offline-mirror mirror gc "$MIRROR_NAME"
        echo "Garbage collection terminée pour $MIRROR_NAME."
    fi

    echo "-------------------------------------------"
done

echo "Nettoyage terminé pour tous les miroirs."

chmod +x /usr/local/bin/clean_proxmox_snapshots.sh

crontab -e

0 0 * * * /usr/local/bin/clean_proxmox_snapshots.sh

Ressources

• https://pom.proxmox.com/offline-mirror.html#setting-up-a-mirror
• Pour le script du chemin statique: https://www.reddit.com/r/Proxmox/comments/1cejzn8/static_path_for_last_proxmox_offline_mirror/

Un mémo sur comment créer un serveur miroir local sous Debian.

Pour ce tuto, je ne vais pas utiliser apt-mirroir ni debmirror mais simplement la commande lftp et comme serveur web Nginx.

De plus, mon miroir local sera dédié pour les distributions et en versions stables de Debian, Ubuntu.

Alors pourquoi lftp et non rsync ? car tout simplemement le proxy local n’accepte que les ports 80, 443 et 21 en sortie.

Préparer l’environnement

• Mettre à jour le système :

apt update && apt full-upgrade -y

apt install lftp nginx -y

mkdir -p /srv/mirrors/{debian,ubuntu}

chown -R www-data:www-data /srv/mirrors
chmod -R 755 /srv/mirrors

Synchroniser les miroirs Debian et Ubuntu

• Miroir Debian :
  • Créer le script suivant pour synchroniser Debian :

  nano /usr/local/bin/sync-debian.sh

• Le contenu du script :

#!/bin/bash

# Variables
BASE_URL_DEBIAN="http://deb.debian.org/debian"
BASE_URL_SECURITY="https://security.debian.org/debian-security"
LOCAL_DIR="/srv/mirrors/debian"
SECTIONS=("bookworm" "bookworm-updates" "bookworm-security")

# Proxy configuration
export http_proxy="http://monproxy.local:8080"
export https_proxy="http://monproxy.local:8080:"

# Options pour lftp
LFTP_OPTS="mirror --parallel=4 --verbose=2 --delete"

# Boucle sur les sections principales (bookworm, bookworm-updates)
for SECTION in "${SECTIONS[@]}"; do
    if [ "$SECTION" == "bookworm-security" ]; then
        # Pour le dépôt de sécurité, utiliser une URL différente
        echo "Synchronisation de $SECTION..."
        lftp -c "$LFTP_OPTS $BASE_URL_SECURITY/dists/bookworm-security $LOCAL_DIR/dists/bookworm-security"
    else
        # Pour les autres sections, utiliser l'URL Debian principale
        echo "Synchronisation de $SECTION..."
        lftp -c "$LFTP_OPTS $BASE_URL_DEBIAN/dists/$SECTION $LOCAL_DIR/dists/$SECTION"
    fi
done

echo "Synchronisation terminée."

chmod +x /usr/local/bin/sync-debian.sh

nano /usr/local/bin/sync-ubuntu.sh

#!/bin/bash

# Variables
BASE_URL_UBUNTU="http://archive.ubuntu.com/ubuntu"
BASE_URL_UBUNTU_SECURITY="http://security.ubuntu.com/ubuntu"
LOCAL_DIR="/srv/mirrors/ubuntu"
SECTIONS=("noble" "noble-updates" "noble-security")

# Proxy configuration
export http_proxy="http://monproxy.local:8080"
export https_proxy="http://monproxy.local:8080"

# Options pour lftp
LFTP_OPTS="mirror --parallel=4 --verbose=2 --delete"

# Boucle sur les sections principales (noble, noble-updates)
for SECTION in "${SECTIONS[@]}"; do
    if [ "$SECTION" == "noble-security" ]; then
        # Pour le dépôt de sécurité, utiliser une URL différente
        echo "Synchronisation de $SECTION..."
        lftp -c "$LFTP_OPTS $BASE_URL_UBUNTU_SECURITY/dists/noble-security $LOCAL_DIR/dists/noble-security"
    else
        # Pour les autres sections, utiliser l'URL Ubuntu principale
        echo "Synchronisation de $SECTION..."
        lftp -c "$LFTP_OPTS $BASE_URL_UBUNTU/dists/$SECTION $LOCAL_DIR/dists/$SECTION"
    fi
done

echo "Synchronisation terminée."

chmod +x /usr/local/bin/sync-ubuntu.sh

Planifier la synchronisation automatique

crontab -e

0 2 * * * /usr/local/bin/sync-debian.sh
0 3 * * * /usr/local/bin/sync-ubuntu.sh

Configurer le serveur web

nano /etc/nginx/sites-available/mirrors

server {
    listen 80;
    server_name mirrors.local;

    root /srv/mirrors;
    index index.html;

    location /debian/ {
        alias /srv/mirrors/debian/;
        autoindex on;
    }

    location /ubuntu/ {
        alias /srv/mirrors/ubuntu/;
        autoindex on;
    }

    }

ln -s /etc/nginx/sites-available/mirrors /etc/nginx/sites-enabled/

nginx -t

systemctl reload nginx

Modification des fichiers sources.list des clients

Il ne reste que la modification des fichiers sources.list sur l’ensemble des serveurs.
Pour ce faire, modifier l’url par l’IP du serveur miroir local pour tous les dépôts.

Afin de déployer les modifcations de chaque serveur, je vous propose d’utiliser Ansible :

ansible-playbook -i inventory.yml update_sources_grouped.yml

Les playbooks Ansible sont disponible ici -> https://github.com/freddL/playbook_add_mirror_local/

Un rapide mémo sur comment désactiver le changement automatique d’adresse MAC d’une interface Wifi afin de se connecter à un réseau wifi géré par liste blanche.

• Editer le fichier /etc/NetworkManager/NetworkManager.conf :

sudo nano /etc/NetworkManager/NetworkManager.conf

[device]
wifi.scan-rand-mac_address=no

sudo nmcli general reload

nmcli connection up nom-de-l'Interface_réseau

Un mémo sur la mise en place d’un cluster en haute disponibilité d’hyperviseurs Proxmox avec un stockage distribuée et redondant Ceph. Cet article traite uniquement de la mise en cluster des noeuds Proxmox ainsi que l’installation et de la configuration de Ceph.

Configuration Réseau des noeuds Proxmox

Chaque réseau sera cablé en topologie MESH et les interfaces réseaux créés dans Proxmox seront des aggrégations en mode Broadcast.
Pour plus d’infos voir cet article : https://memo-linux.com/proxmox-creer-un-cluster-sur-un-reseau-prive-sans-switch/

• Adresse IP public des noeuds Proxmox :
  • pve01 : 10.x.x.1
  • pve01 : 10.x.x.2
  • pve01 : 10.x.x.3
• Réseau Corosync (cluster Proxmox) : 192.168.254.0/24
  • pve01 : 192.168.254.1
  • pve02 : 192.168.254.2
  • pve03 : 192.168.254.3
• Réseau Ceph :
  • Ceph Public 192.168.252.0/24
    • pve01 : 192.168.252.1
    • pve02 : 192.168.252.2
    • pve03 : 192.168.252.3
  • Ceph Cluster 192.168.253.0/24
    • pve01 : 192.168.253.1
    • pve02 : 192.168.253.2
    • pve03 : 192.168.253.3

Mise en cluster des noeuds Proxmox

Avant la mise en cluster, il faut s’assurer absolument que chaque noeud soit à l’heure et synchronisé sur un serveur NTP.

chronyc tracking

• Initialisation du cluster sur un noeud aux choix :

pvecm create nom_cluster --link0 192.168.254.1

pvecm add 10.x.x.1 --link0 192.168.254.2

pvecm add 10.x.x.1 --link0 192.168.254.3

Installation de Ceph

L’installation et la configuration du Ceph sera réalisée via l’interface web de Proxmox.

• Sélectionner un noeud, dans le menu cliquer sur Ceph puis cliquer sur « Install Ceph » :



• Une nouvelle fenêtre s’ouvre, sélectionner la dernière version de Ceph (Reef) et le dépôt No-Subscription puis cliquer sur « Start reef installation » :



• Répondre « Y » puis la touche « Enter » du clavier :



• Une fois l’installation terminée, cliquer sur « Next » :



• Configuration réseau du cluster de Ceph :



• Sélectionner les adresses IP configurées pour chaque réseau Public et Cluster du Ceph :



• Installation et configuration du Ceph terminée :

Cependant, il faut refaire l’étape d’installation du Ceph sur les autres noeuds (sans la partie réseau).

Mise en place du Ceph sur le cluster Proxmox

• Sur chaque noeud, créer le Ceph Monitors :
  • Cliquer dans le menu Ceph, puis cliquer sur Monitor :

  

  • Cliquer cur « Create » :

  

  • Sélectionner le noeud :

  

  • Répéter l’opération sur l’autre noeud afin d’avoir l’ensemble des monitors :

  

• Sur chaque noeud, créer le Ceph Manager :
  • Toujours dans le menu Monitor, au niveau de Manager cliquer sur « Create » :

  

  • Sélectioner le noeud :

  

  • Répéter l’opération sur l’autre noeud afin d’avoir tous les Managers (à savoir, un seul est actif) :

  

• Création des OSD :
  • Pré-requis, il faut que les disques soient configurés en NON-RAID et visible dans le menu « Disks » :

  

  • Opération à réaliser sur chaque noeud, dans le menu Ceph, cliquer sur OSD puis sur « Create: OSD » :

  

  • Sélectionner le premier disque puis cliquer sur « Create » :

  

  • Répéter l’opération pour l’ensemble des disques :

  

• Création du pool Ceph pour le stockage :
  • Toujours dans le menu Ceph, cliquer sur « Pools » puis sur « Create » :

  

  • Donner un nom au pool Ceph puis cliquer sur « Create » :

  

  • Une fois le pool Ceph créé, le stockage est automatiquement créé et partagé aux membres du cluster Proxmox :

  

Mise en place de la HA pour les VMs

nb: Lors de la création d’une machine virtuelle, ne pas oublier de choisir le stockage correspondant au pool Ceph:

Encore à ce jour pour la gestion HA des machines virtuelles, j’utilise cette méthode -> https://memo-linux.com/proxmox-cluster-ha-repartition-de-charge-des-machines-virtuelles/

Un mémo sur comment installer et configurer un serveur VPN Wireguard sur un VPS OpenVZ sous Debian 12 Bookworm.

Pré-requis avant installation de Wireguard

• Activer l’interface TUN/TAP à partir du panel d’administration du VPS :

Installation et Configuration de Wireguard sur OpenVZ

Pour faciliter l’installation et l’utilisation Wireguard sur OpenVZ, il faut passer par la solution boringtun.

• Mise à jour du référentiel de paquets, installation de curl et de l’utilitaire de package cargo :

apt update && apt install curl cargo

cargo install boringtun-cli --locked

ln ~/.cargo/bin/boringtun-cli /usr/local/bin/

curl -O https://raw.githubusercontent.com/angristan/wireguard-install/master/wireguard-install.sh

sed -i 's/^\tcheckVirt/#\tcheckVirt/' wireguard-install.sh

chmod +x wireguard-install.sh

./wireguard-install.sh

sed -i '19 i Environment=WG_QUICK_USERSPACE_IMPLEMENTATION=boringtun-cli' /lib/systemd/system/wg-quick@.service

sed -i '20 i Environment=WG_SUDO=1' /lib/systemd/system/wg-quick@.service

systemctl daemon-reload

systemctl stop wg-quick@wg0

systemctl start wg-quick@wg0

systemctl status wg-quick@wg0

Resources

• https://www.reddit.com/r/WireGuard/comments/rtfi58/easy_way_to_install_wireguard_on_a_openvz_vps/?show=original
• https://www.1996.info/easy-way-to-install-wireguard-on-a-openvz-vps/
• https://github.com/cloudflare/boringtun

Un petit mémo sur comment corriger le message nginx: [warn] the « listen … http2 » directive is deprecated pour une configuration https d’un server block.

En effet, si un de des servers block est configuré en https comme ceci: listen 443 ssl http2; Nginx refusera de valider la configuration.

Pour que la configuration soit valide :

• changer la ligne :

listen 443 ssl http2;

listen 443 ssl;
http2 on;

nginx -t

nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

systemctl restart nginx

• Ressource : https://nginx.org/en/docs/http/ngx_http_v2_module.html

Un petit mémo sur une ligne de commande pour retrouver facilement la licence d’un Windows virtualisé sous Linux.

• Ouvrir un terminal et saisir la commande suivante :

sudo strings /sys/firmware/acpi/tables/MSDM

MSDMU
"HPQOEMSLIC-BPC
HP  
HLKS2-O48DH-K3DJ7-P82P2-5JRTH

simple et efficasse

Un petit mémo sur comment créer simplement une clé bootable multi ISO avec Ventoy de manière graphique.

Installation de Ventoy

• Installer Ventoy :
  • Arch/Manajro (Dépot AUR) :

  yay -S ventoy

sudo tar -xzvf ventoy-*-linux.tar.gz -C /opt

Créer une clé USB multiboot avec Ventoy

• Ouvrir Ventoy :
  • Saisir dans un terminal la commande :

    sudo /opt/ventoy/VentoyGUI.x86_64

    • Le logiciel Ventoy s’ouvre :

    

  • Dans le cas présent, la clé USB a été détectée automatiquemement. Sinon, sélectionner la clé USB souhaité et cliquer sur Install (attention, les données sur clé USB seront entièrement supprimées) :

  

  • Message d’avertissement sur la suppresion total des données, cliquer sur Valider :

  

  • Re message d’avertissement (Double Check) :

  

  • Ventoy a bien été installé sur le clé USB :

  

  • Débrancher puis rebrancher la clé USB sur le PC et la clé est prète à recevoir les ISOs :

  

  • Pour fini copier coller les ISOs sur la clé (perso, j’ai créé un dossier ISO à la racine de la clé USB) :

  

Démarrer sur la clé USB Ventoy

• Faire un test de boot sur la clé USB Ventoy, exemple avec VirtualBox
• Ou directemement su PC :

Gdu pour go DiskUsage() est un petit utilitaire écrit en Go, fort pratique et très rapide d’exécution pour l’analyse d’espace disque sous GNU/Linux. Cet utilitaire d’analyse de disque a été principalement développé pour les disques SSD afin d’utiliser pleinement le traitement parallèle. Gdu peut être évidemment utilisé sur les disques dur mécanique mais avec moins de performance.

Utilisation de gdu

• Une fois installé, taper simplement dans le terminal :

gdu

gdu /home/fred

gdu -d

gdu --help

Installer gdu

• Debian :

apt install gdu

add-apt-repository ppa:daniel-milde/gdu
apt-get update
apt-get install gdu

pacman -S gdu

curl -L https://github.com/dundee/gdu/releases/latest/download/gdu_linux_amd64.tgz | tar xz
chmod +x gdu_linux_amd64
mv gdu_linux_amd64 /usr/bin/gdu

Ressources

• source : https://www.tecmint.com/gdu-disk-usage-analyzer-for-linux/
• https://github.com/dundee/gdu

Un petit mémo sur comment activer le mode maintenance d’un nœud Proxmox au sein d’un cluster.

le mode maintenance dans Proxmox

En deux mots, c’est un mode qui permet comme son nom l’indique de mettre un nœud membre d’un cluster hors ligne sans l’arrêter.
Du coup, les machines virtuelles du nœud en question vont réagir suivant comment a été programmé l’option de la HA dans Proxmox.
Dans mon cas, l’option est configurée en mode Migration :

Dès l’activation du mode maintenance d’un nœud membre du cluster Proxmox, les machines virtuelles vont automatiquement migrées à chaud sur un autre nœud. Cet autre nœud est déterminé dans les groupes créés dans le menu HA.
Dans mon cas, si je met en mode maintenance le nœud pve01-lim, les machines vont migrées automatiquement vers le nœud pve02-lim :

Activer/Désactiver le mode maintenance sur un nœud Proxmox

• Activer le mode maintenance :

ha-manager crm-command node-maintenance enable $(hostname)

ha-manager crm-command node-maintenance disable $(hostname)

Dans mon cas, j’ai ajouté cette commande dans mon playbook de mise à jour de mes noeuds Proxmox :
https://github.com/freddL/playbook_proxmox/blob/master/pve_update.yml
Cette option me permet de migrer les machines virtuelles automatiquement avant la mise à jour et surtout avant le redémarrage des service avec needrestart, ce qui dans certain cas fait redémarrer le nœud et donc provoque une coupure de service des machines virtuelles.

Ressource

• https://pve.proxmox.com/pve-docs/chapter-ha-manager.html#_node_maintenance

Un petit mémo sur les étapes à suivre pour faire la montée de version de proxmox backup server 2 vers 3.

• Point de vigilance : tout comme la montée de version de Proxmox de 7 vers 8, le noms des cartes réseaux PCI peuvent changer ! (dans mon cas, j’ai été surpris car pas de changement)

Pré-requis avant la mise à jour de PBS en version 3

• S’assurer que PBS est bien en version 2 :

  proxmox-backup-manager versions

  • Résultat attendu :

  proxmox-backup-server 2.4.2-2 running version: 2.4.2

tar czf "pbs2-etc-backup-$(date -I).tar.gz" -C "/etc" "proxmox-backup"

df -h /

Filesystem            Size  Used Avail Use% Mounted on
/dev/mapper/pbs-root  250G   12G  226G   5% /

Mise à jour de PBS en version 3

• Passer en mode maintenance le ou les datastores :
  • Exemple dans mon cas :

  proxmox-backup-manager datastore update backup-me5024 --maintenance-mode read-only

  proxmox-backup-manager datastore update nfs-backup --maintenance-mode read-only

sed -i 's/bullseye/bookworm/g' /etc/apt/sources.list

sed -i -e 's/bullseye/bookworm/g' /etc/apt/sources.list.d/*.list

apt update && apt full-upgrade

reboot

proxmox-backup-manager versions

proxmox-backup-server 3.0.1-1 running version: 3.0.1

proxmox-backup-manager datastore update backup-me5024 --delete maintenance-mode

proxmox-backup-manager datastore update nfs-backup --delete maintenance-mode

Ressource

• https://pbs.proxmox.com/wiki/index.php/Upgrade_from_2_to_3

Un petit mémo sur comment résoudre l’erreur TASK ERROR: storage migration failed: target storage is known to cause issues with aio=io_uring (used by current drive) lors d’un déplacement de disque dur d’une machine virtuelle sous Proxmox.

Par défaut sous Proxmox, le disque dur d’un machine virtuelle bénéficie de la technologie io_uring.
Cette technologie de io_uring permet d’augmenter les performances IO d’un disque sous Linux.
Cependant, cette technologie peut poser problème si la destination du stockage est de type iSCSI.
Dans mon cas, stockage source Ceph vers stockage destination baie ISCSI = TASK ERROR: storage migration failed: target storage is known to cause issues with aio=io_uring (used by current drive)

Par contre, j’ai fais l’exercice inverse avec le déplacement de la baie iSCSI vers le Ceph et ça fonctionne parfaitement avec l’option io_uring.

Changer l’option Async IO d’un disque d’une machine virtuelle

• Se positionner dans le menu Hardware de la machine virtuelle, puis double cliquer sur Hard Disk :



• Ouvrir les options avancées en cliquant sur « Advanced » :



• Changer l’option de Async IO pour native :



• Redémarrer la machine virtuelle pour prendre en compte les mortification de l’option :




• Une fois la machine virtuelle redémarré, il est de nouveau possible de déplacer le disque dur vers un autre stockage partagé.

Ressources

• Le forum Proxmox : https://forum.proxmox.com/threads/problems-with-moving-disk-vm.124801/
• Petite présentation de io_uring : https://archive.fosdem.org/2020/schedule/event/vai_io_uring_in_qemu/attachments/slides/4145/export/events/attachments/vai_io_uring_in_qemu/slides/4145/io_uring_fosdem.pdf

Un petit mémo sur comment convertir facilement des fichiers au format Microsoft comme les .docx, .doc ou des fichiers ouverts de type .odf, .odt au format PDF en ligne de commande dans un terminal avec l’outil lowriter de LibreOffice.

Pour la petite histoire, j’avais une quinzaines de documents au format .docx à imprimer via USB mais le photocopieur n’acceptait que les formats .png ou .pdf et je n’avais pas envie des les convertir 1 à 1 via LibreOffice. Du coup, après une petite recherche avec les mots clé « linux convert .docx to pdf« , j’ai découvert l’outil lowriter.

• Convertir des fichiers .docx au formats PDF :

lowriter --convert-to pdf *.docx

Petit bonus, si les noms des fichiers sont « sales » (comme c’est souvent le cas venant du monde de Microsoft), il est possible de passer un petit coup de nettoyage avec l’outil detox

• Ressource : https://ubunlog.com/en/lowriter-documents-to-pdf-terminal/