Sous Win standard :
Panneau de conf -> Système -> propriétés avancés ->

Sous Win Server

Peut être dans clic-droit sur lecteur -> onglet “Clichés instantanés”
Mais si absent on peut retrouver la même fenêtre dans :

compmgmt.msc
Dossier partagés -> clic-droit -> Toutes les tâches -> Configurer les clichés instantanés

à activer au niveau d’un lecteur
Possible de modifier la planification

Ceci va rendre utile l’onglet “versions précédentes” des postes qui accèdent à des partages sur ce lecteur via le réseau

Présentation

Les PC fonctionnent selon différents états d’alimentation (power states).
https://en.wikipedia.org/wiki/ACPI
https://learn.microsoft.com/en-us/windows/win32/power/system-power-states
Lorsqu’un PC est en cours de fonctionnement, il est à l’état S0.
Lorsqu’il est en veille classique, il est à l’état S3.
Lorsqu’il est en hibernation, il est à l’état S4.
Et lorsqu’il est complètement éteint, il est à l’état S5.

Lors d’une veille classique S3, seule la RAM est alimentée en électricité ; tous les autres composants sont éteints.
En ceci, la reprise d’activité est rapide, mais pas instantanée.

Dans le but d’améliorer ceci, la veille “S0 low-power idle” a été créée ; elle maintient plusieurs composants en état de fonctionnement, donc les cartes réseau et le processeur.
Elle est également appelée S0iX.

Typiquement, depuis un autre pc, il reste possible de pinger l’adresse IP d’un poste en veille moderne.

Le PC n’est pas censé faire d’actions gourmandes en énergie, mais de nombreux cas rapportent que le PC se met à chauffer fortement et vider la batterie lors de la veille moderne.

https://learn.microsoft.com/fr-fr/windows-hardware/design/device-experiences/modern-standby

Vérifier les modes de veille supportés

Le support des différents modes de veille dépend de l’UEFi, ainsi que de l’OS.
Les cartes-mères modernent doivent toutes supporter la veille moderne ; certaines supportent encore le mode S3, mais de moins en moins.

Sous Windows

powercfg -a

liste les états d’alimentation supportés par le système.
On peut y voir soit “En veille (S3)” soit “Veille (Mode faible consommation S0) connecté au réseau”.

Lorsque le mode S0 low-power est disponible, le mode S3 est nécessairement désactivé (“Cet état de veille est désactivé lorsque le mode faible consommation S0 est pris en charge”).

Désactiver le mode S0

https://www.makeuseof.com/windows-disable-modern-standby/

Windows Registry Editor Version 5.00
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Power]
"PlatformAoAcOverride"=dword:00000000

reg add HKLM\System\CurrentControlSet\Control\Power /v PlatformAoAcOverride /t REG_DWORD /d 0

Windows Registry Editor Version 5.00
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Power]
"PlatformAoAcOverride"=-

reg delete "HKLM\System\CurrentControlSet\Control\Power" /v PlatformAoAcOverride /f

La gestion des connexions SMB a changé depuis Windows 11 Pro 24H2.
Elle avait déjà changé pour les versions Education, Pro for workstations, Enterprise de Windows 10 et 11.
Elle reste similaire à avant pour Windows 11 Home.

En conséquence de ces changements, Windows exige maintenant que les connexions SMB soient signées, et la bascule sur un accès invité en cas de défaut de signature est désactivée.
Article chez MS

Dans mon cas, il s’agit de l’accès vers un serveur Samba, dont l’accès invité fonctionne correctement et nativement depuis un poste Windows 10.
Avec Windows 11 Pro 24H2, je suis confronté aux 2 problèmes : la signature de la connexion SMB, et l’accès en tant qu’invité.

À noter que la solution ne semble pas fonctionner pour des profils cloud, que pour les utilisateurs locaux du poste. Question de configuration ?

Accès SMB non signé

https://learn.microsoft.com/en-us/windows-server/storage/file-server/smb-signing

Par défaut, Windows 11 Pro (au moins 24H2) exige que les connexions SMB soient signées.
La fonctionnalité de signature ne fonctionne pas avec l’accès invité, il est donc indispensable de la désactiver (source chez MS).

Cela peut se vérifier par la commande Powershell
Get-SmbClientConfiguration | findstr req.*sign
qui doit nous indiquer la valeur de RequireSecuritySignature, probablement à True.

Le problème se manifeste par “Une erreur étendue s’est produite” (si accès depuis la fenêtre “Exécuter”) ou “Windows ne peut pas accéder à my-srv” (si accès depuis la barre d’adresse de l’explorateur).

Pour ceci, j’ai 3 possibilités : le registre, les stratégies locales, ou Powershell.
Ces 3 possibilités sont équivalentes : l’activation (ou désactivation) par une méthode se répercute de manière visible sur les autres méthodes (il faut toutefois fermer/rouvrir les stratégies locales pour actualiser).

Registre :
HKLM\SYSTEM\CurrectControlSet\Services\LanmanWorkstation\Parameters et définir la valeur DWORD
RequireSecuritySignature
à 0

Stratégies locales :
gpedit.msc
Config ordi -> Paramètres Windows -> Paramètres de sécurité -> Stratégies locales -> Options de sécurité
Client réseau Microsoft : communications signées numériquement (toujours)

Powershell :
Set-SmbClientConfiguration -RequireSecuritySignature $false -Force

Connexion en tant qu’invité

Sources pour cette partie :

https://memo.raphaelguetta.fr/post/server-2019-access-guest-share/
https://learn.microsoft.com/en-us/windows-server/storage/file-server/enable-insecure-guest-logons-smb2-and-smb3
https://forum.qnap.com/viewtopic.php?t=175771

Une fois la connexion non-signée autorisée, lorsque je cherche à me connecter à mon serveur, je suis accueilli par une invite d’authentification, sans possibilité de me connecter en invité (alors que mon serveur l’accepte). Ceci car l’accès à des partages sans authentification est désactivé par défaut.

On peut vérifier en lançant la commande Powershell
Get-SmbClientConfiguration | findstr /I enablei
qui nous retourne la valeur de EnableInsecureGuestLogons, probablement False.

Comme pour les signatures, on peut contrôler ce paramètre par le registre, Powershell, ou les stratégies locales.
La stratégie locale a toutefois priorité ! Si elle est est configurée (activée ou désactivée), alors la valeur de l’entrée de registre n’aura aucun impact.
En ce cas, le résultat de Get-SmbClientConfiguration affichera la configuration effective, indépendamment de la valeur de registre.
Set-SmbClientConfiguration continuera de modifier la valeur de registre, mais n’aura pas d’impact sur la stratégie locale.

Registre/Powershell

On peut au choix ouvrir l’éditeur de registre, ouvrir la clé
HKLM\SYSTEM\CurrectControlSet\Services\LanmanWorkstation\Parameters
et ajouter/éditer la valeur DWORD AllowInsecureGuestAuth en la passant à 1.
Il est également possible de lancer la commande Powershell
Set-SmbClientConfiguration -EnableInsecureGuestLogons $true -Force
qui aura pour résultat de créer/modifier cette même valeur registre.

Stratégies locales

gpedit.msc
Configuration ordinateur -> Modèles d'administration -> Réseau -> Station de travail LANMAN
Activer les ouvertures de session invité non sécurisées -> Activé

Poste joint à AzureAD

Le compte est de la forme nom.prenom@domain.com.
Un whoami sur le poste cible renvoie azuread\nomprenom .

Si le paramètre NLA est activé, seul un poste Windows pourra y accéder ; freerdp ne semble pas gérer l’authenfication Kerberos pour le moment ? Voir cette issue.
Pour se connecter depuis Windows, lancer mstsc.exe, aller dans l’onglet Avancé puis Cocher “Utiliser un compte web pour vous connecter à l’ordinateur distant”. On peut laisser le mot de passe vide.
Une fenêtre de connexion web va s’ouvrir.
La connexion reste ensuite établie, et ne demande plus le mot de passe.

On peut également désactiver NLA (sur le poste cible, paramètres avancés du système -> Utilisation à distance).
En ce cas on peut se connecter depuis FreeRDP avec
xfreerdp /v:10.0.10.100 /d:AzureAD /u:nomprenom /p:mypassword /sec:tls
ou encore
xfreerdp /v:10.0.10.100 /u:"AzureAD\nomprenom" /p:mypassword /sec:tls
ou encore
xfreerdp /v:10.0.10.100 /u:AzureAD\\nomprenom /p:mypassword /sec:tls

Sauvegarde des credentials sur les postes qui y accèdent ? Semble se faire tout seul sur un compte local qui accède à un compte AzureAD ?

Compte perso ?

“MicrosoftAccount\nomprenom” ??

Ne pas confondre Microsoft LAPS (=legacy LAPS), ancienne génération pour le on-prem, et Windows LAPS pour le cloud (entra joined et hybrid-joined)

Présentation

LAPS, Local Admin Password Solution, permet de centraliser la gestion des mots de passe des admins locaux sur les postes.

Entra

https://learn.microsoft.com/en-us/entra/identity/devices/howto-manage-local-admin-passwords

Windows LAPS est inclus dans Entra Free, mais des fonctionnalités en + nécessitent d’autres licences (administrative units, custom roles, Conditional Access, and Intune)

Pour l’activer, aller dans
Entra -> Devices -> Overview -> Device settings
et l’activer

Intune

https://learn.microsoft.com/en-us/intune/intune-service/protect/windows-laps-overview

Sharepoint Admin Center

Dans l’admin M365, il y a “All admin centers” dans la colonne de gauche.
Parmi ceux-ci, on trouve celui de Sharepoint.
Ça devrait être https://mycompany-admin.sharepoint.com

Powershell

Il semble y avoir plusieurs modules PS pour SPO, pas tous compatibles avec les mêmes versions de Powershell.

Module PnP.Powershell

Semble fournir plein de commandes pour gérer O365.
Nécessite Powershell 7, installable côte-à-côte de Powershell 5.1. Pour l’installer :
iex "& { $(irm https://aka.ms/install-powershell.ps1) } -UseMSI"
puis
Install-Module -Name PnP.PowerShell
Load-Module PnP.PowerShell

Module Microsoft.Online.SharePoint.PowerShell

https://www.sharepointdiary.com/2019/02/the-term-connect-sposervice-is-not-recognized-as-the-name-of-a-cmdlet-function-script-file-or-operable-program.html

Nécessite Powershell 5.
C’est lui qui fournit les commandes Connect-SPOService, Set-SPOSite etc.

Install-Module Microsoft.Online.SharePoint.PowerShell
Import-Module Microsoft.Online.SharePoint.PowerShell

Pour l’utiliser dans PS7 :
Import-Module Microsoft.Online.SharePoint.PowerShell -UseWindowsPowerShell

Sites

Toutes les ressources d’un site sont accessibles par tous les membres de l’équipe.
(ou pas avec des permissions sur les biblios ? )

Format d’une adresse de site SPO :
https://mycompany.sharepoint.com/sites/my-site

Modifier informations

Aller sur le site -> Engrenage en haut à droite -> Site Information
On peut y changer le nom et la description.

Attention, changer le nom ne change pas l’URL ! Pour la changer, il faut aller dans le centre d’admin -> Active sites
https://learn.microsoft.com/en-us/sharepoint/change-site-address

Sharepoint Designer

Permet de modifier le contenu et les réglages des sites Sharepoint.
Fonctionne avec SharePoint Online si on fait quelques réglages sur SPO.

https://answers.microsoft.com/fr-fr/msoffice/forum/all/sharepoint-designer-et-sharepoint-on-line/8df94e29-8a8c-4593-a9a6-ffc8f13b042b
https://www.sharepointdiary.com/2018/09/sharepoint-online-enable-sharepoint-designer-using-powershell.html

Télécharger Sharepoint Designer :
https://www.microsoft.com/fr-fr/download/details.aspx?id=35491
et le SP1 :
https://www.microsoft.com/fr-fr/download/details.aspx?id=42009
Installer les 2.

Il faut activer la modification de SPO par Sharepoint Designer (c’est-à-dire les scripts customs). On peut le faire par l’interface, mais cela peut mettre jusqu’à 24h à être pris en compte, et c’est pour l’ensemble des sites.
On eut aussi le faire en Powershell, c’est instantané et avec une granularité par site. Pour ceci :

$tenantname = "mycompany"
$sitename = "my-site"
$AdminSiteURL="https://$tenantname-admin.sharepoint.com"
$SiteURL="https://$tenantname.sharepoint.com/sites/$sitename"
$cred = Get-Credential

#Connect to SharePoint Online Admin Center
Connect-SPOService -Url $AdminSiteURL -Credential ($cred)

#Enable SharePoint Designer for the site collection
Set-SPOSite -Identity $SiteURL -DenyAddAndCustomizePages $False

Après cette manip, si on va sur le site -> Settings -> Site information -> View all site settings
est apparu
Site collection Administration -> SharePoint Designer Settings
Si on l’ouvre, on peut cocher “Enable Sharepoint Designer”.

Dans Sharepoint Designer, on fait “Open site” et on entre l’URL du site (company.sharepoint.com/sites/mysite).
Après identification, ça devrait être ok.

Bibliothèques (Library)

Les bibliothèques peuvent avoir plusieurs noms d’affichage, dépendant de la langue ! Sharepoint a en effet un système de “traduction” depuis la langue principale.

Pour connaître la langue principale d’un site, il faut ouvrir le site puis
Settings -> Site information -> View all site settings -> Language settings.

Pour changer le nom d’affichage d’une bibliothèque, il faut l’ouvrir dans la langue souhaitée (par exemple avec l’extension “Language Switch”) puis :
ouvrir biblio -> Settings (engrenage) -> Library settings -> List name, description and navigation
Ainsi, le nom de cette bibliothèque aura changé uniquement dans la langue en question.

Ce paramétrage ne change pas l’URL. Sa valeur équivaut au “InternalName”, et elle ne peut être changée que par Powershell ou Sharepoint Designer.

Changer l’URL par SP Designer

Connecter SP Designer comme indiqué ci-dessus.
Aller dans “All Files” (et PAS dans “Lists and Libraries”)
puis faire un clic-droit sur la biblio et “Rename”
Ceci changera son chemin d’accès (mais pas son nom d’affichage)

À noter que lors de l’affichage de “All Files”, la biblio a un attribut “Title” qui correspond à son nom d’affichage dans la langue principale.
Si on change le nom d’affichage dans la langue principale, l’attribut “Title” sera mis à jour en conséquence.

Si on ouvre Lists and Libraries, on voit apparaître la biblio sous son nom anglais (car SPD est en anglais je suppose).
Si on ouvre les propriétés de la biblio, on peut changer le “Name”, mais ceci ne changera que le nom d’affichage en anglais !

Stockage

stockage : 1To inclus + 10Go/user
20cts/Go supplémentaire

https://learn.microsoft.com/en-us/microsoft-365/commerce/add-storage-space

Office 365 Extra File Storage

Pour voir l’espace disponible/utilisé, aller dans Sharepoint Admin -> Active sites.

https://learn.microsoft.com/en-us/troubleshoot/sharepoint/administration/out-of-storage

Changer URL sharepoint

Si on veut changer le nom de domaine sharepoint

https://learn.microsoft.com/en-us/sharepoint/change-your-sharepoint-domain-name

Voir dans l’explorateur

https://learn.microsoft.com/en-us/sharepoint/sharepoint-view-in-edge

Connect-SPOService -Url https://contoso-admin.sharepoint.com  
Set-SPOTenant -ViewInFileExplorerEnabled $True

Migration

SPO admin center -> Migration

Onedrive

Pour synchroniser une biblio Sharepoint avec Onedrive, il y a 2 possibilités :

• “sync”
• ajouter un raccourci dans son Onedrive perso

Pour différentes raisons, l’option de placer un raccourci vers la biblio est aujourd’hui sensiblement + conseillée que l’option de Sync.
Elle doit toutefois être réalisée individuellement par chaque personne qui doit accéder à la biblio ; elle ne peut pas être déployée automatiquement.

https://learn.microsoft.com/en-us/sharepoint/sync-health?tabs=windows

Config de Onedrive par GPO

https://learn.microsoft.com/en-us/sharepoint/use-group-policy

Auto sync avec Sharepoint

https://learn.microsoft.com/en-us/sharepoint/use-group-policy#configure-team-site-libraries-to-sync-automatically

La valeur à déployer est de la forme :
tenantId=xxx&siteId=xxx&webId=xxx&listId=xxx&webUrl=httpsxxx&version=1

Nécessite de trouver l’ID de la bibliothèque à synchroniser automatiquement.
Pour ça, aller sur le site (pas l’admin), ouvrir la biblio, clic syr le bouton “Sync” puis “Copy library ID”.
On peut ensuite directement coller cette URL dans la valeur de la GPO.

Attention, ce paramétrage peut mettre jusqu’à 8h pour se déclencher.
Possible de forcer avec
TimerAutomount

Gestion de l’espace

https://betterlicenses.com/blog/sharepoint-online-storage-quota-problem-fixing-it
https://learn.microsoft.com/en-us/sharepoint/trim-versions

Limitations

https://support.microsoft.com/en-au/office/restrictions-and-limitations-in-onedrive-and-sharepoint-64883a5d-228e-48f5-b3d2-eb39e07630fa

Dossier perso

http://mycompany-my.sharepoint.com/
renvoie sur son dossier Onedrive personnel (lié au compte pro, pas un vrai onedrive perso)

Compte créé en tant que compte local

Supposons que le compte utilisé soit un compte local, que l’on appellera “admin”.
En ce cas :

• whoami donner hostname\admin

Les paramètres mentionneront “Compte local” en haut à gauche.
L’appareil apparaît dans la liste des appareils sur :
https://account.microsoft.com/devices

Si on va dans Paramètres -> Comptes, des infos sur le stockage cloud etc. sont affichées
Si on va dans Paramètres -> Comptes -> E-mail et comptes, on voit le compte mentionné comme “Compte Microsoft” et on ne peut pas le supprimer, on ne peut que le “Gérer” (ce qui ouvre le site web de MS)

Les applis MS sont connectées automatiquement

Compte créé via un compte MS perso

Si dès la création du compte, on se connecte avec un compte MS
Le username est hostname\abcde avec abcde qui sont les 5 premières lettres du mail associé au compte MS

Les paramètres mentionnent l’adresse mail en haut à gauche.

Déconnexion

Compte perso

Aller dans les Paramètres -> Comptes -> Vos informations
et choisir “Se connecter plutôt avec un compte local”

Une fois déconnecté, le compte Windows devient effectivement un compte local, mais les informations de connexion sont toujours enregistrées. Ainsi, même après déconnexion de Teams, il suffit de sélectionner le compte dans la liste pour l’ouvrir à nouveau, sans besoin de taper le mot de passe.

Ceci est dû au fait qu’après suppression du compte MS, le compte reste dans les Paramètres -> Comptes -> E-mail et comptes
Mais en déroulant ses infos, on peut ici le supprimer. Ainsi, toute re-connexion à ce compte nécessitera le mot de passe.

Compte pro/scolaire

Paramètres -> Comptes -> Accès professionnel ou scolaire

Flexible I/O tester, soit fio, sert à spécifier des charges de travail précises à faire exécuter par des supports de stockage.

sudo apt install fio

Liens :
https://fio.readthedocs.io/en/latest/fio_doc.html
https://linux.die.net/man/1/fio
https://askubuntu.com/questions/87035/how-to-check-hard-disk-performance
https://arstechnica.com/gadgets/2020/02/how-fast-are-your-disks-find-out-the-open-source-way-with-fio/
https://www.virtono.com/community/tutorial-how-to/fio-basics/

Paramètres obligatoires :
--name : le nom du job
--size : la taille du fichier ; obligatoire s’il n’existe pas déjà un fichier ou périphérique à l’emplacement de “filename” ; on peut toutefois une taille inférieure à l’objet existant, et seule cette zone sera utilisée pour le test

Par défaut, c’est un test en lecture seule sur un fichier de 4G.
Attention, si la taille est élevée, elle peut mener à une consommation de RAM élevée par job qui utilise des accès random (randread, randwrite et randrw) ! Dans le cas d’un RAID de 40 To, chaque job consommait environ 1.3 Go de RAM. Si on multiplie les jobs, cela peut mener à l’OOM.
Je suppose que c’est lié au fait qu’il va essayer de répartir les tests sur l’intégralité de la surface du périphérique, qu’il doit donc “mapper”.
Si on spécifie une taille sensiblement plus petite, alors ce problème ne se manifeste pas. Mais cela ne teste le support de stockage que sur une plus petite surface (donc moins de mouvement mécanique, et des résultats plus élevés que des accès sur toutes la surface).
io_size n’a pas d’effet dessus ; c’est size qui importe.

Autres paramètres :

--filename : le fichier (ou bloc ! ) sur lequel sera réalisé le test ; par défaut, c’est ./${jobname} (la valeur de –name) si un seul job, ou jobname.jobnumber.filenumber si plusieurs jobs
--filename_format : permet de personnaliser la génération de filename

--readonly pour de la lecture seule
--readwrite (ou –rw) : définit le type d’opération : read (séquentiel) , write (séquentiel) , randread (aléatoire) , randwrite (aléatoire) , rw (50/50 séquentiel) , randrw (50/50 aléatoire)
--opendir : ouvre séquentiellement tous les fichiers sous le répertoire passé en argument

--io_size : définit la quantité de données à traiter avant d’arrêter fio. Par défaut c’est équivalent à size, mais peut être différent (par exemple pour lire uniquement 5G de données malgré une taille de fichier de 20G, ou à l’inverse lire un total de 10G malgré une taile de fichier de 500m ; en cas il boucle)
--blocksize : par défaut 4096
--ioengine : le moteur d’I/O à utiliser ; par défaut psync ; voir les descriptions ; beaucoup d’exemples semblent utiliser libaio
--fsync= : pour forcer une sync (écriture réelle sur le périphérique) après X écritures
--end_fsync=1 : pour que le timer continue jusqu’à ce que l’OS rapporte que les écritures ont réellement été réalisées
--direct : force la non-utilisation d’un buffer disque ; recommandé de toujours mettre 1 (true)
--refill-buffers : pour forcer le renouvellement des données aléatoires utilisées pour le test

--gtod_reduce=1 : semble réduire les requêtes pour connaître l’heure et améliorer les perfs
--eta-newline : force l’affichage d’une nouvelle ligne après X secondes

En cas de lecture seule, le fichier de test doit être au moins aussi gros que la taille de blocs par défaut (soit 4K).

Bruit et conso

Ces tests peuvent être une bonne manière de tester le bruit et la conso éléctrique d’un disque ; dans mon expérience, les accès aléatoires (que ce soit lecture ou écriture) sont particulièrement bruyants, alors que les accès séquentiels sont quasi inaudibles.

Job files

Syntaxe

; -- start job file --
[global]
rw=randread
size=128m

[job1]

[job2]

; -- end job file --

Chaque jobfile peut contenir 1 ou plusieurs jobs. Si plusieurs présents, il sont parallélisés.
On peut éviter cette parallélisation avec l’option stonewall (ou wait_for_previous) : un job qui possède cette option attendra la fin du/des jobs précédents avant de démarrer. Ce job (et les suivants) feront aussi partie d’un nouveau groupe de rapport.

Chaque job peut également paralléliser des IO (via iodepth ou numjobs).
On peut également fournir plusieurs jobfiles en ligne de commandes, et ils seront exécutés à la suite.

–section
possible de mettre des variables

Utilisation

Pour tester un disque en tant que bloc :
fio --filename=/dev/sdX ./jobfile.txt
Pour écrire le log dans un fichier :
fio --filename=/dev/sdX --output=mydisk.log ./jobfile.txt

Output

https://fio.readthedocs.io/en/latest/fio_doc.html#interpreting-the-output

Au début, le nom de tous les jobs qui seront lancés, avec leurs options.

seqread: (g=0): rw=read, bs=(R) 4096B-4096B, (W) 4096B-4096B, (T) 4096B-4096B, ioengine=psync, iodepth=1
randread: (g=0): rw=randread, bs=(R) 4096B-4096B, (W) 4096B-4096B, (T) 4096B-4096B, ioengine=psync, iodepth=1
randwrite: (g=1): rw=randwrite, bs=(R) 4096B-4096B, (W) 4096B-4096B, (T) 4096B-4096B, ioengine=psync, iodepth=1

g= : leur groupe d’appartenance (je suppose) ; (R) (W) (T) : read write trim

Pendant le test, Une ligne de type :
Jobs: 1 (f=1): [_(1),r(1),P(1)][45.4%][r=20.9MiB/s][r=5350 IOPS][eta 00m:53s]
Jobs: 1 (f=1) : le nombre jobs en cours dans le groupe (f=nombre de fichiers ouverts)
[_(1),r(1),P(1)] : l’état de l’ensemble des jobs prévus ; voir table dans la doc pour + de détails ;
les principaux états : _ = correctement fini ; rwmdRWMD : read/write/mixed/trim (MAJ=seq,min=rand) ;
P = job planifié pour plus tard ; X = erreurs ; K = interrompu
Puis pour chaque test (ou groupe si group_reporting) :

• des infos test1: (groupid=0, jobs=1): err= 0: pid=1519610: Sun Feb 25 11:25:53 2024
• des valeurs de latences (slat = submission latency, clat = completion latency, lat = total latency)
• des valeurs de bande passante et d’IOPS
• statistiques sur la latence, les IOPS, la bande passante etc

bench-fio et fio-plot

Un programme existe, fio-plot, qui permet de faire des graphs en utilisant les résultats de fio comme source de données.
Git : https://github.com/louwrentius/fio-plot qd Il est nécessaire que les données soient au format JSON, et que l’arborescence suive une formé précise.

Le + simple pour les créer semble être d’utiliser le script bench-fio fourni avec fio-plot.

Installation

Ne semble pas dispo dans les dépôts Debian.
Les instructions disent d’utiliser pip3 pour l’installer, mais Debian (trixie) m’informe que c’est mieux avec pipx. Donc on y va :
pipx install fio-plot

Les binaires se trouvent dans ${HOME}/.local/bin/ , et sont en fait des liens vers ${HOME}/.local/share/pipx/vens/fio-plot/. On y trouve notamment bench-fio et fio-plot.

Le chemin devrait être dans le ${PATH}, mais si besoin de lancer en root, il faudra sûrement donner le chemin complet.

Utilisation

bench-fio est un wrapper autour de fio. Il utilise un fichier INI qui définit les combinaisons à tester pour une même cible (fichier, périphérique etc…).

Dans le cas d’un RAID, en RAW (attention destruction de données), ce fichier INI pourrait être :

[benchfio]
output = ./results

# si on travaille sur un périphérique bloc
target = /dev/sdX
type = device
## on peut spécifier la taille ; par défaut c'est tout le device
#size=10G
## on peut choisir de travailler au début ou à la fin du périphérique avec offset
## la zone comprise dans offset sera ignorée pour le test
#extra_opts = offset=119G

## sinon on peut travailler sur un ficher ; 
#target = /mountpoint/file
#type = file
## dans ce cas la taille doit être spécifiée
#size = 500G
## il faut que le fichier existe déjà
## si la taille est différente de ce qui est demandé, le fichier est intégralement écrit avant le début des tests, ce qui peut être très long
## on peut créer le fichier à l'avance avec une commande :
## fio --name=preparation --filename=/ZFS/TMP --rw=write --bs=1M --size=500G --direct=1 --ioengine=libaio --buffer_compress_percentage=0 --refill_buffers



## par défaut le test s'arrête au bout de 30 secondes ; on augmente à 300s
runtime = 300
# on peut aussi désactiver le timer
#runtime = 0

## on choisit les combinaisons que l'on veut tester
## l'ordre peut avoir une importance en matière de gestion du cache
mode = randread,randwrite,randrw,rw,read,write
rwmixread=60

numjobs = 1,10,25
block_size = 4k, 64k, 1M

## HDD
iodepth = 1,64,512
## SSD
#iodepth = 1,16,64


direct = 1
engine = libaio
precondition = False
precondition_repeat = False
destructive = True

## opts pour que les données soient différentes à chaque itération (pour éviter l'effet cache) et ne soient pas compressibles
refill_buffers = 1
buffer_compress_percentage = 0
invalidate = 1
## invalidate devrait être activé par défaut

type doit nécessairement être défini. Il peut s’agir, entre autres, de directory, device, file ou rbd (lié à Ceph).

Certaines valeurs sont définies par défaut ; notamment le runtime, qui si non spécifié, est de 60 secondes, soit 1 minute max par test ; je l’ai monté ici à 300s (5 minutes).
Chaque test se finit dès que la taille spécifiée est traitée OU que le temps de runtime s’est écoulé.

Le paramètre “invalidate” de fio est par défaut à 1, c’est-à-dire que le cache est invalidé avant chaque test. Mais pour ceci, si la cible est de type “device”, il est nécessaire d’être root pour pouvoir invalider le cache.

Pour lancer le bench, il suffit de faire bench-fio ./bench.ini.
Ceci va nous créer (dans le dossier actuel) un dossier ${output}/${target}/${block_size} ; donc ici results/md0/4k , qui contiendra des fichiers JSON de type $mode-$iodepth-$numjob , par exemple “read-16-32.json”, ainsi qu’un fichier .log pour chaque job de chaque test ! Ça peut donc vite se compter en 10aines de milliers si on met beaucoup de combinaisons.

Choix des valeurs

Dans mon expérience :

Sur un SSD NVMe performant (Samsung 990 Pro),

• il est inutile de monter depth au-delà de 64 ; même avec 1 seul job, il n’y a aucun gain
• une taille de secteur de 4k donne des meilleurs résultats que 16k, et + stables, sauf sur

Génération des graphs

Une fois que le benchmark est fini, on peut genérer un graph avec fio-plot .
La syntaxe minimale doit inclure le dossier ou chercher les résultats (source des graphs) avec -i, le titre du graph avec -T, la mesure (read, randwrite etc) à laquelle on s’intéresse avec -r et le type de graph ; par exemple :
fio-plot -i results/md0/4k -T MONSUPERGRAPH -r read -l
En l’absence de précisions, il va chercher les valeurs pour les queue depths 1 2 4 8 16 32 64 et uniquement 1 en numjob.
Si une de ces combinaison est manquante dans les les données, la création de l’image échouera. On peut alors préciser ces valeurs avec -d pour depth et -n ; selon le type de graph, il peut être possible de séparer plusieurs valeurs par des espaces ; par exemple :
-d 1 4 16 64 -n 2 16 32

Les types de graph sont :

• -l pour un graph 2D avec des barres représentant les IOPS et la latency, selon la queue depth (1 seul numjob par graph)
• -N pour un graph 2D avec des barres représentant les IOPS et la latency, selon le numjob (1 seul queue depth par graph)
• -L pour un graph 3D avec des barres représentant, au choix grace à l’option -t, les IOPS, ou la latence (lat, slat, clat) ou le débit ; les valeurs possibles sont bw,iops,lat,slat,clat ; on peut cumuler les valeurs de queue depth et numjob
• -H pour un histogramme (quel pourcentage des valeurs est contenu dans chaque tranche de valeur) de la latence ; 1 depth et 1 numjob par graph (si on en spécifie plusieurs, seule la première valeur est prise en compte)
• -g pour des courbes en fonction du temps ; on choisit une métrique avec -t (parmi bw,iops,lat,slat,clat) et autant de numjobs et qd que souhaité ; on aura 1 courbe par combinaison de qd et nj

À ma connaissance, seuls les graph -L et -g permettent de voir la bande passante en MO/s.

https://arstechnica.com/information-technology/2020/05/zfs-101-understanding-zfs-storage-and-performance/
https://unixdigest.com/articles/battle-testing-zfs-btrfs-and-mdadm-dm.html
https://openzfs.org/wiki/Newcomers
https://openzfs.github.io/openzfs-docs/Project%20and%20Community/FAQ.html
https://blog.victormendonca.com/2020/11/03/zfs-for-dummies/
https://www.reddit.com/r/zfs/
https://forum.level1techs.com/t/zfs-guide-for-starters-and-advanced-users-concepts-pool-config-tuning-troubleshooting/196035

Généralités

ZFS est une architecture qui combine des fonctionnalités de gestion de volumes, et de système de fichiers.

Recommandé de conserver au moins ~10% d’espace libre (ou 500Go, le + petit des 2 devrait être ok) dans le pool pour éviter de sérieusement dégrader les performances.

Architecture

zpool

Géré avec la commande zpool.

Le plus gros ensemble sous ZFS s’appelle un zpool. Il est constitué de 1 ou plusieurs vdevs, chaque vdev étant constitué d'1 ou plusieurs périphérique (disque physique, partition, mapper LUKS, fichier etc).

Une fois crée, le zpool peut directement être monté en tant que système de fichier, mais il est aussi possible d’y créer des dataset, qui peuvent eux-même être montés.

On peut également créer des zvol (volumes) au sein d’un zpool, qui pourra être accédé comme un périphérique bloc : il sera possible de le formater avec un autre FS.

Considérations sur la structure d’un pool et son évolution :
https://openzfs.github.io/openzfs-docs/Basic%20Concepts/Pool%20Structure/Changing%20Pool%20Layout.html
Globalement, en cas de RAIDZ, il sera impossible de retirer un vdev (même non-raidz) du pool.

dataset

Gérés avec la commande zfs.

Représente un ensemble de données, géré comme une unité.
C’est au niveau du dataset que sont gérés les snapshots.
On peut aussi créer un dataset enfant sous un dataset parent, avec la possibilité d’hériter des propriétés du parent.

Bien que ce ne soit pas exactement la même chose, ça s’approche des subvolumes de btrfs.

snapshot

zfs snap[shot]
Forcément en read-only. Pour écrire dedans il faut faire un clone.

Toujours de la forme dataset@snapshot

Lister les pools et les datasets

zfs list
zfs list -t all
-t peut être filesystem, snapshot, volume, bookmark, all ; par défaut fs only

zfs list -j pour du json

RAIDZ et redondance

Le RAIDZ est un système de parité analogue au RAID (bien que fonctionnant différemment).
Le RAIDZ-1 contient 1 disque de parité (analogue au RAID5). Le RAIDZ-2 contient 2 disques de parité (analogue au RAID6).
Il existe aussi le RAIDZ-3 avec 3 disque de parité.

ZFS peut aussi fonctionner en mode miroir (analogue au RAID1), cette fonctionnalité est simplement appelée “mirror”.

ARC

https://openzfs.github.io/openzfs-docs/Basic%20Concepts/Pool%20Structure/Caching.html

ZFS fait une utilisation assez intensive des caches, si disponibles.
Il y a un cache primaire de lecture en RAM, le ARC (Adaptive Replacement Cache).
On peut définir un ARC de 2nd niveau sur disque rapide (L2ARC). Il consomme aussi de la RAM, donc si on a des limites basses de RAM, il peut être contre-productif (l’ARC sera plus petit pour laisser la place à l’indexation du L2ARC). À la grosse louche, environ 1G de RAM pour 30G de L2ARC (mais ça dépend du recordsize de chaque fichier).
Voir plus bas.

Persistence ?

ZIL

ZFS Intent Log
C’est l’endroit où sont écrites les demandes d’écriture synchrones.
Par défaut, ce sont des blocs du pool ; mais on peut définir un vdev spécial dans ce but (le SLOG (Separating Intent Log), type log).
Il faut de la protection (Power-loss Protection, redondance etc) sinon des données seront perdues.

special

https://openzfs.github.io/openzfs-docs/Basic%20Concepts/Pool%20Structure/Special%20vdev.html

vdev qui va stocker certains données spéciales ; notablement les metadonnées.
Permet de grandement limiter les random IO dans le cas de disques HDD si on met les metadonnées sur un SSD.
Attention, perdre un special vdev équivaut à perdre le pool entier !

Si le pool contient au moins un RAIDZ, il est impossible de retirer le vdev special ; il sera donc définitif.
En d’autres cas, il devrait être possible de supprimer un vdev special après son ajout.

Install

Recommandé de l’installer depuis les backports
Besoin de la section contrib

sudo apt install -t stable-backports zfsutils-linux zfs-dkms

Il y a aussi le paquet zfs-initramfs
Nécessaire pour avoir un /boot ou un / en ZFS ?

zpool

C’est un ensemble logique complet pouvant être utilisé avec ZFS. Il est constitué de 1 ou plusieurs vdev.
Au sein d’un zpool, les données sont réparties entre les différents vdev de stockage (ou de support).

Il n’y a pas de redondance au sein d’un zpool : si un seul vdev vient à manquer, l’ensemble du zpool est perdu !

C’est au sein de chaque vdev que l’on va s’assurer d’une redondance si nécessaire.

Le zpool contient directement un dataset, qui peut être monté. Il est aussi possible d’y créer des dataset enfants et sous-enfants.
Il y a un héritage des propriétés (qui peut être modifié).

Tout se gère avec la commande zpool.

vdev

Un vdev représente une unité de stockage, au sein du zpool.
Il y’a plusieurs types de vdev, etre autres :

• ceux de stockage, qui peuvent être en simple disque, en mirror (équivalent RAID1), en RAID-Z (équivalent RAID5-6)
• ceux de support :
• CACHE
• LOG
• SPECIAL

Un vdev est constitué de 1 ou plusieurs devices, qui peuvent être des périphériques blocs ou des fichiers.

ashift

ashift représente la taille de secteurs des disques d’un pool, en puissance de 2.
Défini à la création du pool, ne peut plus être modifié par la suite !
9 : 2⁹ = 512
12 : 2¹² = 4096
9 peut être intéressant pour les vieux HDD en addressage logique et physique 512, mais sinon 12 sera sûrement plus adapté et performant.
Si on ne le spécifie pas, il est détecté automatiquement. Mais il est possible que la détection soit incorrecte, notamment avec les disques 512e.

Pour la vérifier, on peut faire :
zdb -C | grep ashift
ou
zpool get ashift

Il y a aussi la commande
zpool get ashift mypool all-vdevs
qui donne le ashift de chaque vdev sous-jacent ; mais celui-ci n’a pas d’importance ; il changera si le pool est exporté puis importé. Il définit juste le niveau d’ashift qui sera utilisé pour l’autodétection si on crée un vdev dessus.
https://github.com/openzfs/zfs/issues/16838

atime

zfs get atime mypool[/dataset]
zfs set atime=off mypool

Commande zpool

Permet de gérér les pools et les vdev.
Les vdev sans chemin absolu sont cherchés dans /dev/

Création d’un pool

man zpool create

De la forme

poolname = "myzpool"
sudo zpool create -o ashift=12 -m mountpoint $poolname dev1 dev2 [redundancy] dev3 dev4 [redundancy] dev5 dev6 dev7

On peut mettre mountpoint=none

On peut spécifier une nature de redondance pour chaque vdev, puis on spécifie les devices (ou fichiers) qui entreront dans ce vdev.
Dans le cas ci-dessus, nous aurons 4 vdev : dev1, dev2, une redondance entre dev3 et dev4, et une redondance entre dev5, dev6 et dev7.
Nous aurons probalement un message d’erreur nous informant que la redondance n’est pas régulière entre les différents vdev.

La redondance peut prendre entre autres ce valeurs : mirror , raidz (équivalent à raidz1) , raidz2 , raidz3. Peut-être single ?

Le zpool est importé/monté dans le système dès sa création s’il a un point de montage.

Cas simple : un seul périphérique :
sudo zpool create $poolname /dev/disk/by-id/ata-XXX

Nommage des devices

ZFS garde le chemin du device en tant un propriété du device dans le zpool ; pour le voir :
zpool get path mypool sdX
Le nom doit être comme dans zpool status (on peut aussi utiliser l’UUID, avec -g).
C’est ici que sera cherché le device en cas de zpool online mypool sdX
Cette propriété est définie à l’import du pool.
Voi le fichier /etc/zfs/zpool.cache
Pour cette raison, il est conseillé de choisir une méthode + fiable que /dev/sdX pour définir les devices (par ex /dev/disk/by-id/).
À l’export, les données sont “oubliées” et seront redétectées à l’import suivant (il analyse les GUID pour déterminer la topologie).

Si on besoin de remettre online un disque sur un autre chemin, mais SANS arrêter le pool, il faut modifier la propriété :
zpool set path=/dev/sdY mypool sdX
Ainsi le device sera toujours nommé sdX au sein du zpool, mais il ira chercher le block /dev/sdY
On peut alors zpool online mypool sdX

Paramètres à la création

Lors de la création d’un pool, certains paramètres sont choisis définitivement.
Les principaux à mentionner me semblent être ashift et le chiffrement.

D’autres paramètres peuvent être changés par la suite, mais la modification n’affecte pas les données déjà existantes. Par exemple, la compression, ou le recordsize.

Lister les pools

zpool status
Les chiffres READ WRITE et CKSUM comptent le nombre d’erreurs de chaque catégorie sur chaque vdev.
Il y a un “watch” intégré : zpool status 1 par ex.

Sortir les données en json :
zpool status -j | jq
donne beaucoup d’infos détaillés sur chaque composant.

man zpool status
Beaucoup d’options intéressantes
-s : pour identifier les vdev lents

zpool list -v -P
Permet de voir l’usage disque de chaque pool et même de chaque vdev.
Attention, on voit l’espace total, et non l’espace utilisable. Pour un RAIDZ2, la valeur affiché ici ne tient pas compte des 2 disques de parité.
Voir zfs list pour voir l’espace utilisable.

Historique des commandes

zpool history mypool
Permet de voir l’historique des commandes ayant agi sur ce zpool.
Par défaut ça ne met que les commandes entrées par l’utilisateur ; si on veut aussi voir les autres évenemnts (achèvement d’une commande par ex.) on peut utiliser
zpool history -i mypool

Ajouter un vdev à une pool

zpool add $poolname device

Dans les vdev : attach/detach

zpool attach $poolname device new_device
permet d’ajouter un disque/fichier à un vdev.
S’il s’agit d’un miroir ou directement d’un disque, le disque sera ajouté en tant que miroir.

S’il s’agit d’un RAIDZ, le RAIDZ est agrandi en prenant en compte le nouveau disque, et en conservant son niveau fonctionnel (un raidz2 reste un raidz2, mais avec 1 disque en plus.
Pour ça, l’ensemble des données est réécrite sur le raidz

sudo zpool detach $poolname device

Permet de supprimer un disque d’un miroir ou d’un “replacing-X”.
Impossible de supprimer un disque d’un vdev en raidz ?

scrub

Consulter l’état du scrub :
zpool status mypool à côté de scan:

  scan: scrub in progress since Wed Oct 14 00:26:32 2026
	3.07T / 1.60T scanned, 776G / 1.60T issued at 842M/s
	0B repaired, 47.32% done, 00:17:30 to go

“scanned” c’est assez rapide, c’est genre l’indexation, mais “issued” c’est la vraie vérif des données, c’est beaucoup plus long.
Je pense qu’on est à 3.07T indexés sur 1.60T réellement utilisés grâce à la dedup de très gros fichiers.

Lancer (ou continuer) un scrub :
sudo zpool scrub mypool

Mettre en pause un scrub :
sudo zpool scrub -p mypool

Annuler un scrub :
sudo zpool scrub -s mypool

Pool suspendu

Si un vdev vient à manquer, le pool est suspendu.
S’il est encore disponible (par exemple un disque qui a été déconnecté mais qui fonctionne correctement), il devrait de le rebrancher, puis d’entrer la commande
sudo zpool clean $poolname
ça devrait “resynchroniser” le pool, et remettre le compteur d’erreurs à 0 partout.

Dans mon expérience, même en déconnectant un disque en plein milieu d’une copie de fichier vers le pool, si on le reconnecte et que l’on cleane, le transfert se finit correctement et le fichier ne sera pas corrompu.
À condition que le chemin du device soit le même que précédemment ! D’où l’intérêt d’utiliser des chemins fixes (by-id).

Si le vdev est définitivement perdu, il ne sera pas possible de récupérer les données du pool.

Lister les propriétés d’une pool

zpool get all $poolname
ou plus finement
zpool get property1,property2 $poolname

Détacher une pool

sudo zpool export $poolname

Trouver et importer des pools inactives

sudo zpool import
va lister les pools détectés (et inactifs)
Par défaut, ça va chercher sur les périphériques dispos dans /dev/. Les informations concernant l’appartenance à un pool sont trouvées dans la table de partition du périphérique.

On peut spécifier un dossier ou device à chercher avec l’option -d. Nécessaire pour importer un pool créé sur des fichiers.

sudo zpool import $poolname [newpoolname]
Permet de la rendre disponible, éventuellement en changeant son nom.

Détruire (et tenter de restaurer) un pool

zpool destroy $poolname

Ceci essaye de démonter tous les datasets, puis détruit le pool (avec tous les datasets contenus). Aucune confirmation n’est demandée.
Ceci permet d’utiliser les disques qui étaient dans le pool pour un autre usage.
Cette suppression supprime les métadonnées du pool, mais les données restent intactes (tant qu’on n’écrit pas dessus).

Si la destruction est une erreur, on peut lister les pools supprimés avec :
zpool import -D
et si c’est bon, on peut les importer automatiquement avec
zpool import -a -D

Commande zfs

Sert à gérer les datasets.

Créer un dataset

zfs create -o property=value mypool/mydataset

Monter un dataset

zfs mount $poolname
va monter dans le chemin défini dans la propriété mountpoint

Lister les montages ZFS

zfs mount
ou
mount | grep "type zfs"

Lister les propriétés des datasets

zfs get all [mydataset]
ou + finement
zfs get property1,property2 [mydataset]

Les propriétés dont la source est “default” sont définies à la volée, selon les valeurs par défaut (par exemple, le mountpoint sera /datasetname).
Les propriétés définies explicitement sur le dataset auront comme source “local”, et font partie intégrante du dataset, même si celui-ci est branché sur une autre machine.

zfs list
man zfs list
zfs list -t all -r

Espace disque

zfs list -o space : vue par dataset avec la répartition entre espace utilisé par le dataset lui-même (USEDDS), par les snapshots (USEDSNAP), par les enfants (USEDCHILD) et par les réservations
zfs list -t snapshot -o name,used,refer : l’espace propre à chaque snapshot
zfs destroy -nv pool/ds@snapA%snapB : simulation de suppression d’une plage de snapshots, qui indique l’espace récupérable. Très utile pour savoir ce que libérerait un nettoyage
zpool list -v et zpool iostat -v : vue au niveau pool et vdevs
zdb -DD pool : statistiques de dedup

Définir des propriétés des datasets

sudo zfs set property=value mypool/mydataset

On peut aussi enlever une valeur explicite et remettre par défaut avec la commande
sudo zfs inherit property mypool/mydataset

Chiffrement

Il s’active au niveau du dataset (y compris le dataset racine si activé). L’activation du chiffrement est décidée à la création du dataset, et ne pourra plus être changée. S’il besoin de modifier le chiffrement du dataset, il faut en créer un nouveau et transférer les données.

À noter que certaines metadonnées ne sont pas chiffrées : nom des datasets, leurs propriétés, la structure du pool, tailles globales.
Les fichiers et metadonnées de fichiers sont chiffrés.

Il y’a par défaut un héritage du chiffrement : des datasets enfant héritent du chiffrement du parent.
Il est toutefois possible de spécifier un chiffrement différent (clé, pas, voire pas de chiffrement) lors de la création du dataset enfant (-o encryption=off).
La notion de encryptionroot désigne le niveau d’arborescence où a été définie la clé utilisée pour ce dataset.

Le chiffrement se fait avec une clé maitresse. Celle-ci est stockée directement sur le dataset, sous forme chiffrée par une clé d’enveloppe (wrapping key) ; en gros même architecture que sous LUKS.
L’algo de chiffrement (cipher) est forcément AES ; toutes les combinaisons de 128,192 et 256 bits, et des modes ccm et gcm. Cet algo n’est pas modifiable après la création du dataset chiffré.
Hors cas particulier (rétrocompatibilité, pas d’accélération hw crypto etc), le mieux est aes-256-gcm et c’est le choix par défaut (encryption=on).
L’algo choisi chiffre directement les données, et ce sera aussi celui utilisé pour chiffrer la clé maitresse.

La clé d’enveloppe peut être de format raw, passphrase ou hex. C’est la property keyformat.
Si c’est raw, c’est directement la clé d’enveloppe ; pour AES-256 elle doit faire 32 octets (soit 256b). À conserver privée !
Si c’est hex, c’est exactement comme raw, mais au format hexadecimal ; plus pratique à manipuler, permet de la gérer sous format texte (fichier lisible, C/C etc). Fera donc 64 caractères hexadecimaux.
Si c’est passphrase, alors la clé est dérivée de la passphrase (salted), comme une graine (par l’algo pbkdf2-hmac-sha1), avec un certain nombre d’itérations (pbkdf2iters, par défaut 350000). L’entropie de la clé dépend alors de la sécurité/longueur de la passphrase, et le nombre d’itérations sert à ralentir le bruteforce (son efficacité est toutefois relative ; il faut une bonne passphrase).

keylocation : l’endroit où va être récupérée la clé d’enveloppe.
Ça peut être de la forme prompt, file:///path/to/keyfile ou https://server.example.com/key-file
C’est uniquement une indication ; peut être surchargé par zfs load-key -L

Il est possible de changer le chiffrement de la clé d’enveloppe (keyformat,keylocation,pbkdf2iters) :
zfs change-key -o keyformat=raw -o keylocation=file:///root/new.key

Si on utilise un fichier clé, celui-ci doit nécessairement être d’exactement 32 octets (soit 236 bits). L’algo utilisé est AES-256. Pour en créer une :
dd if=/dev/urandom of=./zfs_key bs=32 count=1
Pour un ficher hex on peut faire :
``

Créer dataset chiffré

Par clé :
sudo zfs create mypool/datacrypt -o encryption=on -o keyformat=raw -o keylocation=file:///path/to/keyfile

Ouvrir un dataset chiffré

zfs load-key zfs load-key -L

Voir le statut de chiffrement des pools et datasets

Uniquement les datasets chiffrés :
zfs list -r -o name,encryption,encryptionroot,keyformat,keystatus,keylocation | awk '$2 != "off"'

Uniquement les encryptionroot (datasets qui ont leur propre clé) :
zfs list -r -o name,encryption,encryptionroot,keyformat,keystatus,keylocation | awk '$1 == $3'

Uniquement les datasets verrouillés :
zfs list -r -o name,encryption,encryptionroot,keyformat,keystatus,keylocation | awk '$5 == "unavailable"'
Uniquement les déverrouillés :
zfs list -r -o name,encryption,encryptionroot,keyformat,keystatus,keylocation | awk '$5 == "available"'

Autre possibilité, avec tous les datasets :
zfs get name,encryption,encryptionroot,keyformat,keystatus,keylocation [mypool/dataset]

Autre propriété qui existe : pbkdf2iters (nombre d’itérations) .
keystatus : est-ce que la clé est chargée en RAM ?

Pour entrer la clé manuellement :
sudo zfs load-key mypool/datacrypt

dataset racine chiffrée

zdb

ZFS debugger

Outil très puissant, qui fonctionne principalement en lecture seule, mais a certaines options d’écriture.
Certaines opérations demandent beaucoup d’IO (lecture/vérif de l’ensemble du FS par exemple).
À utiliser idéalement sur pool non-importé.

Lancée sans argument, sudo zdb équivaut à sudo zdb -C et affiche un récap texte des pools.
On y voit notamment txg, qui est un suivi incrémentiel des transactions.
On peut y voir aussi not_present: 1 pour un children absent d’un vdev.

sudo zdb MyPool : va instantanément lancer une analyse en profondeur du pool, scannant l’ensemble des données, et monopolisant les IO.
Il n’a d’intérêt que pour debugger un système ZFS corrompu, qu’on ne peut pas importer etc.
Un simple scrub est suffisant lorsque le système fonctionne correctement et s’importe bien.

sudo zdb -l /dev/sdX
Va lire les infos d’appartenance à un pool de /dev/sdX.

On peut notamment y voir le numéro de txg (transactions groups), qui représente l’avancée des écritures dans le temps :
sudo zdb -l /dev/sdX | grep -i " tx"
Si le disque fait partie d’un pool importé, la valeur est le txg lors de l’importation.
Si le disque est hors-ligne, c’est la valeur du dernier txg écrit dessus.
Si le disque a été débranché quelques temps, on peut comparer son avancement avec celui du pool importé en cours de fonctionnement :
sudo zdb -u MyZpool | grep -i "txg "

tail -n 3 /proc/spl/kstat/zfs/MyZpool/txgs

while [ 1 ]; do for i in $(ls /dev/mapper/); do echo $(sudo zdb -l $i | grep -i " tx"); done ; sleep 1 ; done

ARC

https://openzfs.github.io/openzfs-docs/Basic%20Concepts/Pool%20Structure/Caching.html

Le cache ARC est un mécanisme de mise en RAM de certaines données ; notamment les données très récentes et les données fréquemment accédées.

La quantité max octroyée au cache ARC dépend de la quantité de RAM mais peut être assez élevée.
Pour voir la quantité max et la quantité utilisée, on peut passer par htop en customisant l’affichage.

zarcsummary
zarcstats

Sinon on peut voir le max avec
cat /proc/spl/kstat/zfs/arcstats | grep c_max
et la quantité actuellement utilisée avec
cat /proc/spl/kstat/zfs/arcstats | grep -E "^size"

Il faut diviser les valeurs par (1024³) pour avoir les valeurs en Go, et (1024²) pour avoir les valeurs en Mo.

Activer ou désactiver ARC

Cette fonctionnalité peut être désactivée pour certains dataset si nécessaire (utile par exemple pour des tests de perf fio).
On peut vérifier le statut d’activation du cache avec :
zfs get all | grep -i primarycache

et le désactiver avec
sudo zfs set primarycache=none monpool/fio-test

ou le réactiver avec
sudo zfs set primarycache=all monpool/fio-test
ou par défaut avec
sudo zfs inherit primarycache monpool/fio-test

L2ARC

Le cache ARC de niveau 2 est un device spécial (typiquement un SSD), qui n’est pas obligatoire, et dans lequel se déverse le cache RAM qui devient trop vieux.

Pour voir si on en a un, il faut regarder la sortie de
zpool status
et voir si un device cache est mentionné.

On peut aussi faire
cat /proc/spl/kstat/zfs/arcstats | grep l2_size
pour avoir la taille en octet.

Si on souhaite le désactiver, essayer comme ci-dessus avec secondarycache au lieu de primarycache.

Santé et remplacement d’un RAIDZ-2

Dans cet exemple, j’ai un pool constitué d’un seul vdev, lui-même constitué de 8 fichiers en RAIDZ-2.
J’ai volontairement corrompu ce vdev en supprimant 2 fichiers.

Lorsque l’on liste les pools et les vdev, le pool ainsi que le vdev se trouvent dans l’état DEGRADED. Chacun des 2 devices (en l’occurence fichiers) se trouve dans l’état FAULTED.
FAULTED signifie que le device sous-jacent est toujours pris en compte dans le vdev, mais inaccessible ou défectueux (par exemple disque en panne, ou débranché, ou fichier supprimé).

Il y a aussi l’état OFFLINE, qui signifie que le device sous-jacent a été sorti du vdev, qui est en attente d’un remplacement pour ce device.
On peut volontairement passer un device en OFFLINE avec la commande :
sudo zpool offline $poolname device

Aussi état “UNAVAIL”. Dit quel était le précédent device (was /dev/mapper/sde)

Lorsqu’un device est sain (“ONLINE”), son nom/chemin est indiqué dans la sortie de zpool status ou zpool list -v -P.
Lorsqu’un device est absent (FAULTED, OFFLINE ou UNAVAIL), ce sera son GUID qui sera indiqué.
On peut obtenir les GUID de tous les device, même les sains, avec zpool list -v -P -g.

Pour remplacer une disque/fichier offline ou faulted :

sudo zpool replace $poolname $oldGUID /dev/sdX
sudo zpool replace $poolname $oldGUID ./file.dat

Ça devrait automatiquement lancer un resilvering. Pendant ce temps, un device replacing-1 apparaît dans le vdev, qui a lui-même son propre GUID et est composé de l’ancien et du nouveau device.

Il peut y avoir l’erreur cannot replace OLD_GUID with sdX: sdX is busy
J’ai eu ça en essayant de réajouter un disque qui avait déjà fait partie du pool. Même après wipefs -af sur les partitions puis sur la table de partition, le disque restait “busy”.
J’ai résolu l’erreur en réinitialisant le SSD comme ceci
Je suppose qu’en écrivant l’ensemble du SSD avec des 0 ça peut fonctionner aussi.
Essayer zpool labelclear ?

Deduplication

Permet d’économiser de l’espace de stockage lorsque l’on stocke plusieurs fois des blocs de données identiques.
Nécessiter beaucoup de ressources : beaucoup de RAM, et il est conseillé d’avoir des SSD dédiés pour stocker la table de dédup (DDT).
Globalement il n’est pas conseillé de l’activer, sauf cas spécifiquement adapté.

zdb -S MyPool pour simuler l’impact (analyse tout le pool)

Overhead

https://wintelguy.com/2017/zfs-storage-overhead.html

L’espace “slop space” est réservé par le FS pour être sûr d’avoir de la place pour certaines opérations critiques, même en cas de saturation du stockage.
Par défaut il devrait être à 1/32e du stockage total.

Monitoring

Voir l’activité des disques toutes les 1 sec :
qqzpool iostat 1

man zpool iostat

zpool status permet de voir (ligne scan:) si une opération ZFS est en cours (scrub, resilver), ou de voir la dernière date du scrub

CoW

Le Cow ne peut pas être désactivé sur ZFS.
Pour éviter les dégradations de performances, cela se fait via la config de ZFS.

Si on a des zvol, il faut faire correspondre volblocksize au FS invité (par défaut 128k ?).
Pour les VMs ou les DB, on joue sur recordsize.

Selon la criticité des données, on peut désactiver les requêtes synchrones ; elle sont alors groupées en RAM et flushées toutes les 5 secondes ; ceci expose à une perte de données.

zfs set sync=disabled tank/vm-dataset

https://call4cloud.nl/deploy-printer-drivers-intune-win32app/
https://www.microcloud.nl/intune-local-ip-printer-deployment/

L’idée générale est de prendre un poste vierge, d’installer la/les imprimantes dessus, et d’exporter les imprimantes.
Il y’a plusieurs méthodes pour ça.
Je me penche pour l’instant sur printBrm.

PrintBRM

Cet outil exporte l’ensemble des imprimantes, ports et pilotes du poste actuel, dans un fichier .printerExport , et les restaure d’un bloc également.
C’est simple, mais peu souple.
Il faut bien avoir noté le nom du port et de l’imprimante, pour les désinstaller correctement via le script de desinstall.

Attention, il n’est pas dans le PATH, donc il faut indiquer son chemin complet :
C:\Windows\System32\spool\tools\printBrm.exe

Création de l’export

On peut utiliser un poste tout fraichement installé, sur lequel on installe les imprimantes à déployer.
On exporte l’ensemble du système d’impression, en GUI :
printmanagement.msc

Sous “Serveurs d’impression”, clic-droit sur “hostname (local)” -> “Exporter les imprimantes vers un fichier”
Cela va créer un fichier .printerExport.

On peut aussi faire l’export en CLI plutôt que de passer par la GUI :
C:\Windows\System32\spool\tools\printBrm.exe /B /F my-export.printerExport

Vérification de l’export et import manuel

Pour inspecter le fichier :
C:\Windows\System32\spool\tools\printBrm.exe /Q /F my-printers.printerExport

Pour le restaurer :
C:\Windows\System32\spool\tools\printBrm.exe /R /F my-printers.printerExport

Attention à ne PAS mentionner .\ avant le fichier .printerexport, sans quoi on a un “File not found”.
Il faut mettre soit juste le nom de fichier s’il est dans le même dossier, soit le chemin complet.

Création du script d’installation

c:\windows\Sysnative\spool\tools\printbrm.exe /R /F my-printers.printerExport

Script de désinstallation

$printername = "Imprimante Bureau"
$portname = "PortImprBureau"

Remove-Printer "$printername"
sleep 5
Remove-PrinterPort -Name "$portname"

Commands

Install :
powershell -executionpolicy Bypass .\deploy-printer.ps1

Uninstall :
powershell -executionpolicy Bypass .\remove-printer.ps1

Détection de l’installation

Présence de la clé de registre :
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Print\Printers\PRINTER NAME
Clé Name
Valeur : PRINTER NAME

Exporter les préférences d’impression

Les manipulations précédentes permettent d’exporter/importer les imprimantes, les ports et les pilotes, mais pas les paramètres d’impression !