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).

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]
target = /dev/md0
output = results
type = device
mode = read,randread,write,randwrite
size = 5G
iodepth = 1,2,4,8,16,32,64
numjobs = 1,2,4,8,16,32,64
direct = 1
engine = libaio
precondition = False
precondition_repeat = False
runtime = 30
destructive = True
block_size = 4k

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 baissé ici à 30s.
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.

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

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

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, ou éventuellement fichier).

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 aussi créer un dataset enfant sous un dataset parent, avec la possibilité d’hériter des propriétés du parent.

On peut également créer des 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 (par exemple ext4).

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é).

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 RAIDZ (équivalent RAID5-6)
• ceux de support :
• CACHE
• LOG
• SPECIAL

device

dataset

snapshot

clone

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 ?

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’une pool

man zpool create

De la forme

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

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 et dev6.
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 raidz1 raidz2, raidz3.

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

Note il est conseillé de choisir une méthode + fiable que /dev/sdX pour définir les vdev, car en cas de changement de lettre, il faudra supprimer le fichier /etc/zfs/zpool.cache (ou exporter la pool) puis réimporter la pool.

ashift

Lister les pools

zpool status
Les chiffres READ WRITE et CKSUM comptent le nombre d’erreurs de chaque catégorie sur chaque vdev.

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.

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 (+ facile pour tester).
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

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 ou OFFLINE), 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 foncitonner aussi.

zpool attach / detach

zpool attach $poolname device new_device
permet d’ajouter un disque/fichier à un device.
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”.

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

Ajouter un vdev à une pool

zpool add $poolname device

Détacher une pool

sudo zpool export $poolname

Trouver et importer des pools inactives

sudo zpool import
va lister les pools détectés
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.

Commande zfs

Monter un dataset

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

Lister les montages ZFS

zfs mount

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êem si celui-ci est branché sur une autre machine.

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

Définir des propriétés des datasets

sudo zfs set property=value mydataset

ARC

RAIDZ

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), mais il ne me semble pas que cette fonctionnalité soit appelée “RAIDZ”.

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é.

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.

scrub :

Gérer Mémoire mac allouée : AFS peut être gourmand en RAM

CoW et VMs Le CoW crée une légère baisse de perf, qui peut vraiment s’amplifier pour des fichiers avec des écritures fréquentes, comme les VMs ou les BDD voir pour désacitver CoW pour certains fihiers/dossiers/volumes ?

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 !

Ensemble de modules Az

https://learn.microsoft.com/en-us/powershell/azure/install-azps-windows

Install-Module -Name Az -Repository PSGallery -Force

Va installer plein de sous-modules

Module Azure AD

Install-Module -Name AzureAD
Connect-AzureAD

Module Azure Storage

Install-Module -Name Az.Storage
Connect-AzAccount

Gestion des utilisateurs

Désactiver l’expiration du password pour 1 utilisateur

$mail = "user@mondomaine.fr"
Set-AzureADUser -ObjectId $mail -PasswordPolicies DisablePasswordExpiration

Présentation

Présentation chez MS
Planification
Guide de déploiement

Fonctionne par groupe de synchronisation (sync group), qui associe un/plusieurs point(s) de terminaison local (server endpoint : le chemin sur le serveur) et un point de terminaison distant (cloud endpoint : un partage Azure Files).
Pass par l’installation d’un agent sur chaque serveur à configurer (supporté à partir de Server 2016, ou 2012R2 avec Windows Management Framework).

Sur le serveur, il est nécessaire que le lecteur soit en accès direct (propriétaire du filesystem), et en NTFS.
Les liens durs et symboliques seront ignorés.

L’accès par clé doit être activé sur le compte de stockage.

Les données seront synchro en bi-directionnel ; toutefois, la propagation cloud -> serveurs locaux sera plus lente que le sens inverse (“This is because Azure Files today lacks an efficient change detection mechanism like Windows Server has, so changes to the Azure file share directly will take time to propagate back to the server endpoints”).
En gros une tâche planifiée (“change detection job”) est déclenchée toutes les 24h, l’agent va alors scanner tous les fichiers et détecter les changements.

Il faut déployer un “Storage Sync Service”.
Un serveur ne peut faire partie que d’un seul “Storage sync Service”. MS conseille globalement d’utiliser un seul SSS.

Maximum 30 partages par serveur.

Mise en place de l’infrastructure

Préparation du serveur

Sur chaque serveur sur lequel l’agent de sync sera installé, désactiver “Internet Explorer Enhanced Security Configuration”.
Gestionnaire de serveur -> Serveur local -> Section “Proprietés” -> Configuration de sécurité renforcée d’IE -> les 2 à Non

Création du Storage Sync Service (SSS)

Azure portal -> Create ressource
chercher “Azure File Sync” -> Create
Choisir l’abonnement Azure ; choisir le groupe de ressources concerné ; donner un nom ;
Le réseau devrait être ok par défaut; Valider la création.

Installation de l’agent de synchronisation

Télécharger ici le paquet correspondant à la version du serveur.
Install classique.
Sera installé dans le dossier : C:\Program Files\Azure\StorageSyncAgent\
Peut être configuré pour utiliser Windows Update.

Inscription du serveur auprès du service de sync

Il faut avoir les rôles Owner ou Contributor sur le SSS.

Au lancement de l’interface Azure Files Sync, il est demandé d’inscrire le serveur. On choisit “AzureCloud”, on se connecte, et on sélectionne la bonne ressource.
Si l’interface ne se lance pas, lancer C:\Program Files\Azure\StorageSyncAgent\ServerRegistration.exe

On peut alors le voir sur le portail Azure, sur la ressource SSS, dans “Sync -> Registered servers”

Création du groupe de synchro

Un groupe de synchro équivaut à un dossier cloud.
Il faut faire la suite pour chaque nouveau groupe de synchronisation.

Azure Portal -> trouver la ressource (par exemple via le groupe de ressource, ou le menu de service “Storage Sync Services”

Sync -> Sync groups -> Create sync group
On donne un nom, on choisit l’abonnement, le compte de stockage, le partage Azure
Le groupe de synchro est alors créé, mais n’a aucun “server endpoint”

Création du point de terminaison serveur

Il faut maintenant créer un SEP (Server EndPoint).
À faire sur chacun des serveurs qui sera dans le groupe de synchro.
Attention, le choix du lecteur et du chemin sur le serveur est définitif ! Il ne pourra pas être modifié par la suite.

Ouvrir le groupe de synchro -> Add server endpoint
Choisir le serveur
Entrer le chemin local des données à synchroniser (avec la lettre de lecteur)
Activer si besoin le cloud tiering

Initial sync : uniquement disponible pour le 1e serveur que l’on synchronise.
MS conseille de conserver “Merge” dans la majorité des cas, même si la source ou la destination est vide.

Initial download : aucun impact si le partage est vide.
“Namespace first, then content” semble adapté pour avoir toutes les données en local.
Ne pourra pas être changé par la suite !

On peut alors valider ; ça va créer le SEP, et la synchro sera déclenchée quelques temps plus tard.

Forcer la synchro

On peut forcer la synchro depuis le cloud vers le serveur avec la commande Invoke-AzStorageSyncChangeDetection.
https://learn.microsoft.com/en-us/powershell/module/az.storagesync/invoke-azstoragesyncchangedetection

On définit nos ressources :

$rgname = "myressourcegroup"  
$sss = "mysyncservice"  
$sgname = "mysyncgroup"

Ensuite, on récupère le GUID du point de terminaison cloud :

$cep = (Get-AzStorageSyncCloudEndpoint -ResourceGroupName $rgname -StorageSyncServiceName $sss -SyncGroupName $sgname).CloudEndpointName

puis on force la synchro :

Invoke-AzStorageSyncChangeDetection -ResourceGroupName $rgname -StorageSyncServiceName $sss -SyncGroupName $sgname -Name $cep

Dépannage

https://learn.microsoft.com/en-us/troubleshoot/azure/azure-storage/files/file-sync/file-sync-troubleshoot-sync-errors

Décommissioner un serveur

https://learn.microsoft.com/en-us/azure/storage/file-sync/file-sync-server-endpoint-delete

Si on veut retirer un serveur, il faut d’abord s’assurer que tous ses changements on bien été transférés vers le cloud.
Observateur d'evts -> Journaux des applications et services -> Microsoft -> File Sync -> Agent -> Telemetry
Chercher un evt 9102 récent.

Autres indications sur le portail Azure :
Storage accounts -> file share -> used size
SSS -> Sync group

• 0 persistent sync error
• server endpoint -> sync status
• Upload et Download ont des timestamps récents

Pour être sûrs que des nouvelles données ne soient plus écrites sur le serveur, on désactive le partage réseau du serveur.
ATTENTION, ne pas modifier les droits d’accès sur le serveur pour empêcher l’accès, sinon cette modification sera répliquée sur Azure.
S’il n’est pas possible de supprimer le partage (par exemple plusieurs dossiers partagés sous un seul chemin), il faudra changer le chemin d’accès sur le serveur (par ex. renommer le dossier) à la fin de la manip.

On peut alors supprimer le “server endpoint”, puis le “cloud endpoint”, puis le groupe de synchro.

Powershell

cd 'C:\Program Files\Azure\StorageSyncAgent'
Import-Module -Name .\StorageSync.Management.ServerCmdlets.dll/subscriptions/xx-xxxx-xxxx/resourceGroups/MonGroupeRessources/providers/Microsoft.StorageSync/storageSyncServices/ServiceSynchroFichiers/registeredServers/xxx-xxx-xxx

NE FONCTIONNE PAS FINALEMENT lors du chiffrement systeme du 2e OS, l’entete du 1er OS déjà chiffré est remplacée par l’entete du 2nd. Le 1er OS est alors “déverrouillé” avec le password du 2e OS, mais la partition est illisible et ça fait écran bleu avec fichier introuvable. On peut réparer la situation uniquement avec le veracrypt rescue disk créé au moment du chiffrement du 1er os, et choisir l’option “k” . Ceci rendra toutefois le 2e OS non bootable à son tour.

Essayer avec bitlocker pour le 2e OS ?

Ancien article :

But : avoir 2 installs Windows distinctes (en + d’une debian), chacune chiffrée par Veracypt, et que le choix se fasse via GRUB et sans avoir à choisir au sein de windows boot manager.

Si 2 installs Windows coexistent au sein d’une même ESP, alors ils partageront la même BCD, et comme le choix de l’OS intervient après le boot de l’OS et donc du déchiffrement Veracrypt, ça rend la solution non viable.

Solution (hacky) : avoir 2 ESP.

Structure du disque (table GPT) :

• 1 partition ESP1 (FAT32, 500m, flag boot)
• 1 partition ESP2 (FAT32, 500m, SANS le flag boot)
• 1 partition WIN1 (NTFS, 50G ou +)
• 1 partition WIN2 (NTFS, 50G ou +)
• partitions nécessaires pour Debian, avec éventuellement LUKS (auquel cas 1 partition pour /boot )

Démarche générale :

• Installer Win1

• Installer Debian

• Vérifier le double-boot via GRUB

• Installer Veracrypt sur Win1, chiffrer la partition système (ceci remplace notamment EFI\Microsoft\Boot\bootmgfw.efi par le lanceur de Veracrypt)

• Vérifier le boot de Win1 chiffré en direct, puis via GRUB. Remettre GRUB en lanceur par défaut dans l’UEFI

• Booter Debian, copier le code GRUB (section dans /boot/grub/grub.cfg) de lancement de Win1 dans /etc/grub.d/40_custom pour être sûr de le conserver(on peut renommer l’entrée pour + de clarté)

• Via efibootmgr, supprimer les 2 entrées Veracrypt et Windows Boot Manager (essentiel pour éviter les conflits)

• Via Gparted enlever le flag boot sur ESP1, le positionner sur ESP2

• update-grub (il ne devrait plus avoir d’autre OS détécté par os-prober, seulement l’entré manuelle)

• Installer Win2

• Vérifier le triple-boot via GRUB

• Installer Veracrypt sur Win2, chiffrer la partition système

• Booter Debian, copier le code GRUB de lancement de Win2 dans /etc/grub.d/40_custom

• Via efibootmgr, supprimer les 2 entrées Veracrypt et Windows Boot Manager

• Via Gparted enlever le flag boot sur ESP2, le positionner sur ESP1

• update-grub

Normalement grub sera le seul OS référencé par l’EFI, il y’aura 1 entrée pour chacun des windows chiffrés, et chaque windows sera complètement indépendant d’un point de vue fichiers de démarrage.
On peut toutefois toujours monter la partition d’une install windows depuis l’autre en fonctionnement.

https://www.thomas-krenn.com/en/wiki/Link_Aggregation_and_LACP_basics
https://fr.wikipedia.org/wiki/IEEE_802.3ad

LAG : Link Aggregation Group : agrégation statique (tous les paramètres sont manuels)

LACP : Link Aggregation control Protocol : configuration automatique des propriétés du lien entre 2 périphériques ; les 2 doivent supporter LACP sinon ça ne fonctionne pas. Spécification IEEE 802.3ad

Synology

Selon mes tests, le Adaptative Load Balancing répartit bien le flux lors d’un téléchargement sur 2 PC en parallèle (le Synology choisit le chemin), mais le flux n’est pas réparti en envoi (le switch envoie les 2 connexions sur le même port).

En mode LACP (si le switch le supporte), la connexion est répartie aussi bien en envoi qu’en réception (1Gbps sur 2 connexions simultanées).