MENU
  1. Accueil
  2. Windows
  3. PowerShell
  4. PowerShell : créer un quota FSRM avec une taille décimale (ex. 1,48 GB)

PowerShell : créer un quota FSRM avec une taille décimale (ex. 1,48 GB)

PowerShell

Besoin de créer un quota FSRM avec une taille comme 1,48 GB et pas seulement un entier ? Voici des méthodes fiables en PowerShell, plus des explications utiles (arrondis, unités, pièges, automatisation, vérifications) pour des quotas précis et reproductibles.

Sommaire

Définir un quota FSRM avec une taille décimale via PowerShell

Vue d’ensemble de la question

Le cmdlet New‑FsrmQuota reçoit un paramètre -Size qui attend un entier non signé (UInt64) en octets. Comment lui passer une valeur non entière comme 1,48 GB sans se tromper ? La réponse tient à la façon dont PowerShell gère les littéraux d’unité (KB, MB, GB, TB, etc.) et les conversions numériques automatiques.

Réponse & solutions (résumé exécutable)

ÉtapeCommande ou explication
Utiliser la notation décimale directementPowerShell convertit un littéral numérique suivi d’un suffixe d’unité (KB, MB, GB, TB) en octets, y compris avec des décimales : New-FsrmQuota -Path 'D:\Folder1' -Size 1.48GB La valeur est convertie en octets et arrondie à l’entier le plus proche pour correspondre au type attendu UInt64.
Calculer manuellement en octets (si l’environnement refuse la décimale)$size = [uint64](1.48 * 1GB) # 1GB = 1 073 741 824 octets New-FsrmQuota -Path 'D:\Folder1' -Size $size Vous gardez le contrôle sur l’arrondi (voir plus bas). Utile sur des environnements limités ou des scripts qui imposent une conversion stricte.
Vérifier le quota crééGet-FsrmQuota -Path 'D:\Folder1' | Format-List Path,Size

Comprendre ce que fait réellement PowerShell

Le type attendu par -Size

  • -Size attend un UInt64 exprimé en octets.
  • Quand vous écrivez 1.48GB, PowerShell interprète GB comme un multiplicateur binaire (230) et produit une valeur numérique en octets.
  • Conversion et arrondi : si la valeur est décimale, PowerShell la convertit implicitement vers UInt64 en l’arrondissant à l’entier le plus proche (comportement .NET standard). Si vous préférez un plancher (arrondi inférieur) ou un plafond, utilisez explicitement [math]::Floor ou [math]::Ceiling.

Unité binaire : GB signifie 230 octets

En PowerShell, 1GB vaut 1 073 741 824 octets. Autrement dit, GB est une unité binaire (proche de GiB) et non la valeur décimale de 109 octets. Idem pour KB, MB, TB, etc. C’est parfait pour FSRM, qui attend une valeur en octets sans ambiguïté.

Point ou virgule ?

Utilisez toujours le point comme séparateur décimal dans un littéral numérique PowerShell, même sur un système francophone. La virgule (,) a une signification syntaxique particulière en PowerShell (opérateur de tableau) et 1,48GB sera interprété… tout sauf comme vous l’attendez.

Exemples de conversions (décimal ⇢ octets)

Voici quelques tailles fréquentes avec leur conversion binaire en octets :

EntréeCalcul binaireArrondi à l’octet le plus prochePlancher (tronqué)
0.10GB0.10 × 1 073 741 824107 374 182107 374 182
0.25GB0.25 × 1 073 741 824268 435 456268 435 456
0.50GB0.50 × 1 073 741 824536 870 912536 870 912
1.48GB1.48 × 1 073 741 8241 589 137 9001 589 137 899
1.50GB1.50 × 1 073 741 8241 610 612 7361 610 612 736
2.75GB2.75 × 1 073 741 8242 952 790 0162 952 790 016
10.001GB10.001 × 1 073 741 82410 738 491 98210 738 491 981

Astuce : si vous écrivez New-FsrmQuota -Size 1.48GB, laissez PowerShell arrondir naturellement. Si votre politique impose un arrondi systématique inférieur, préférez :

$size = [uint64][math]::Floor(1.48 * 1GB)
New-FsrmQuota -Path 'D:\Folder1' -Size $size

Procédure détaillée et bonnes pratiques

Prérequis

  • Serveur Windows avec le rôle File Server Resource Manager (FSRM) installé.
  • Session PowerShell en mode administrateur.
  • Dossier cible existant (ex. D:\Folder1).

Si besoin, installez FSRM :

Install-WindowsFeature -Name FS-Resource-Manager -IncludeManagementTools

Créer un quota « décimal » en une ligne

New-FsrmQuota -Path 'D:\Folder1' -Size 1.48GB  # env. 1,48 GiB en octets

Créer un quota avec maîtrise explicite de l’arrondi

Plancher (jamais au-dessus de la valeur visée) :

$sizeFloor = [uint64][math]::Floor(1.48 * 1GB)
New-FsrmQuota -Path 'D:\Folder1' -Size $sizeFloor

Plafond (jamais en-dessous) :

$sizeCeil = [uint64][math]::Ceiling(1.48 * 1GB)
New-FsrmQuota -Path 'D:\Folder1' -Size $sizeCeil

Arrondi standard (entier le plus proche) :

$sizeRound = [uint64][math]::Round(1.48 * 1GB, 0)  # 0 décimale = arrondi à l'octet
New-FsrmQuota -Path 'D:\Folder1' -Size $sizeRound

Vérifier et afficher le quota

Get-FsrmQuota -Path 'D:\Folder1' | Format-List Path,Size

Par défaut, Size s’affiche en octets. Pour un affichage lisible en « GB », ajoutez un petit calcul :

Get-FsrmQuota -Path 'D:\Folder1' |
  Select-Object Path, @{n='SizeGB'; e={ '{0:N2}' -f ($_.Size / 1GB) }}

Modifier ou supprimer un quota existant

# Ajuster la taille
Set-FsrmQuota -Path 'D:\Folder1' -Size 1.5GB

# Supprimer le quota

Remove-FsrmQuota -Path 'D:\Folder1' -Confirm:$false

Créer un modèle réutilisable (template)

Les modèles rendent l’application cohérente et rapide :

New-FsrmQuotaTemplate -Name 'Quota_1.5GB' -Size 1.5GB
New-FsrmQuota -Path 'D:\Projet' -Template 'Quota_1.5GB'

Soft vs Hard Quota

  • Hard quota (par défaut) : bloque les écritures au-delà de la limite.
  • Soft quota : n’empêche pas l’écriture mais permet d’alerter et de suivre l’usage.

Pour créer un quota souple, ajoutez le commutateur adapté (selon votre version de FSRM) ou utilisez un modèle qui le définit. Exemple indicatif :

New-FsrmQuota -Path 'D:\Staging' -Size 1.48GB -SoftLimit

Curatez des modèles distincts « Hard » / « Soft » afin de standardiser vos pratiques.

Automatiser à grande échelle

Appliquer des quotas « décimaux » à une liste de dossiers

Créez un fichier CSV (quotas.csv) avec ces colonnes :

Path,SizeGB
D:\Teams\A,1.25
D:\Teams\B,1.75
D:\Teams\C,0.5

Puis exécutez :

$rows = Import-Csv -Path '.\quotas.csv'
foreach ($r in $rows) {
    $p = $r.Path
    $g = [double]$r.SizeGB
    # Arrondi standard au byte le plus proche :
    $bytes = [uint64][math]::Round($g * 1GB, 0)
    if (-not (Test-Path -LiteralPath $p)) {
        Write-Warning "Dossier introuvable: $p"
        continue
    }
    if (Get-FsrmQuota -Path $p -ErrorAction SilentlyContinue) {
        Set-FsrmQuota -Path $p -Size $bytes
        Write-Host "Quota mis à jour: $p -> $g GB"
    } else {
        New-FsrmQuota -Path $p -Size $bytes
        Write-Host "Quota créé: $p -> $g GB"
    }
}

Valider avant d’appliquer (simulation)

Ajoutez -WhatIf pour voir ce qui se passerait sans modifier le serveur :

New-FsrmQuota -Path 'D:\Folder1' -Size 1.48GB -WhatIf

Contrôler l’espace et anticiper

Vérifier l’espace libre du volume

Avant d’imposer des quotas, vérifiez que le volume offre suffisamment d’espace résiduel :

Get-PSDrive -Name D | Select-Object Name, @{n='FreeGB'; e={ '{0:N2}' -f ($_.Free/1GB) }}, @{n='UsedGB'; e={ '{0:N2}' -f (($_.Used)/1GB) }}

Compression, déduplication et quotas

FSRM calcule sur l’espace disque réel, donc après compression/déduplication. Si vos fichiers se compressent bien, vous pouvez observer une marge qui varie dans le temps. Évitez les limites trop « serrées » sur des jeux de données très volatiles ou très compressibles.

Fonctions utilitaires

Convertir un littéral humain (ex. « 1.48GB ») en octets

Pour parser des entrées utilisateurs (avec ou sans unité) et uniformiser les arrondis :

function Convert-ToBytes {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true)]
        [string]$InputLiteral,
        [ValidateSet('Round','Floor','Ceiling')]
        [string]$Mode = 'Round'
    )
    $s = $InputLiteral.Trim().ToUpperInvariant()

```
# Si seule une valeur numérique est fournie, on suppose des GB
if ($s -match '^[0-9]*\.?[0-9]+$') { $s = "$s`GB" }

# Extraire valeur et unité
if ($s -notmatch '^([0-9]*\.?[0-9]+)\s*(KB|MB|GB|TB|PB|EB)$') {
    throw "Format invalide: '$InputLiteral' (ex. 1.48GB, 750MB, 0.5TB)"
}
$value = [double]$matches[1]
switch ($matches[2]) {
    'KB' { $factor = 1KB }
    'MB' { $factor = 1MB }
    'GB' { $factor = 1GB }
    'TB' { $factor = 1TB }
    'PB' { $factor = 1PB }
    'EB' { $factor = 1EB }
}

$raw = $value * $factor
switch ($Mode) {
    'Floor'   { return [uint64][math]::Floor($raw) }
    'Ceiling' { return [uint64][math]::Ceiling($raw) }
    default   { return [uint64][math]::Round($raw, 0) }
}
```

}

Exemples :

Convert-ToBytes '1.48GB'           # 1 589 137 900
Convert-ToBytes '1.48GB' -Mode Floor   # 1 589 137 899
Convert-ToBytes '750MB'             # 786 432 000
Convert-ToBytes '0.5TB'             # 549 755 813 888

# Utilisation directe avec FSRM

New-FsrmQuota -Path 'D:\Data' -Size (Convert-ToBytes '1.48GB')

Pièges fréquents et dépannage

ProblèmeCause probableSolution
1,48GB ne fonctionne pasLa virgule est l’opérateur de tableau en PowerShellUtilisez 1.48GB (point), ou [double]'1,48' -replace ',' , '.' si vous devez normaliser des saisies utilisateur.
Erreur de type sur -SizeChaîne non convertible en UInt64Fournissez une expression numérique (ex. 1.48GB) ou calculez en octets avec [uint64](…).
« Quota already exists »Un quota est déjà défini sur le cheminUtilisez Set-FsrmQuota -Path … -Size … pour modifier au lieu de New-FsrmQuota.
FSRM introuvableRôle non installé ou service arrêtéInstallez la fonctionnalité FSRM, puis vérifiez le service (Get-Service SrmSvc / Start-Service SrmSvc).
Différences entre affichage et calculArrondis (octets ⇄ GB) et unités binairesAppliquez une formule cohérente d’affichage (Size / 1GB) et documentez la base (binaire).

Bonnes pratiques d’exploitation

  • Standardisez par modèles FSRM : créez des modèles Hard/Soft à 0.5, 1.0, 1.5, 2.0 GB, etc., pour accélérer et sécuriser les déploiements.
  • Ajoutez une description : consignez le contexte (projet, équipe, date, contact) pour faciliter les audits.
  • Planifiez les seuils d’alerte : même sans blocage, prévenez à 80 % / 90 % pour anticiper une extension.
  • Vérifiez la cible : refusez ou ajustez les quotas qui dépassent l’espace disponible du volume.
  • Automatisez la conformité : exécutez un script de contrôle (CI/CD, tâche planifiée) qui compare l’état réel aux standards et corrige.

Exemples prêts à l’emploi

Créer un quota de 1,48 GB sur plusieurs dossiers

$paths = 'D:\Folder1','D:\Folder2','D:\Folder3'
$bytes = [uint64][math]::Round(1.48 * 1GB, 0)

foreach ($p in $paths) {
if (-not (Test-Path -LiteralPath $p)) { Continue }
if (Get-FsrmQuota -Path $p -ErrorAction SilentlyContinue) {
Set-FsrmQuota -Path $p -Size $bytes
} else {
New-FsrmQuota -Path $p -Size $bytes
}
}

Convertir une contrainte métier « en MB » vers FSRM

Si vos règles internes parlent en « MB », la conversion reste identique :

$mb = 1536  # 1,5 GB ≈ 1 536 MB (base binaire)
$bytes = [uint64]($mb * 1MB)
New-FsrmQuota -Path 'D:\Lab' -Size $bytes

Afficher tous les quotas >= 1,25 GB (lisible)

Get-FsrmQuota |
  Where-Object { $_.Size -ge (1.25 * 1GB) } |
  Select-Object Path, @{n='SizeGB'; e={ '{0:N2}' -f ($_.Size / 1GB) }} |
  Sort-Object SizeGB

FAQ

Peut-on écrire 1,48GB avec une virgule ?

Non. Utilisez 1.48GB. La virgule en PowerShell crée un tableau et ne représente pas un séparateur décimal.

GB est-il décimal (109) ou binaire (230) ?

En PowerShell, les suffixes KB, MB, GB, TB, etc., sont binaires. 1GB = 1 073 741 824 octets.

Que se passe-t-il exactement avec l’arrondi ?

La conversion vers UInt64 arrondit à l’entier le plus proche. Pour un contrôle strict, faites le choix explicite : [math]::Floor, [math]::Ceiling ou [math]::Round.

Comment afficher les tailles en « GB » dans Get‑FsrmQuota ?

Divisez la propriété Size par 1GB et formatez :

Get-FsrmQuota | Select Path, @{n='GB';e={ '{0:N2}' -f ($_.Size/1GB) }}

Dois-je préférer les modèles (templates) ?

Oui, pour la cohérence et la maintenabilité. Créez des templates (Hard/Soft), nommez-les clairement, et appliquez-les à l’échelle.

Conclusion

Pour définir un quota FSRM « décimal », la méthode la plus simple est d’utiliser un littéral avec unité : -Size 1.48GB. PowerShell convertit automatiquement la valeur en octets, avec un arrondi cohérent. Si vous avez des exigences spécifiques (arrondi inférieur/supérieur), basculez vers un calcul explicite en octets avec [math]::Floor / [math]::Ceiling. En combinant ces techniques, des templates, et un peu d’automatisation, vous déployez des quotas précis, reproductibles et faciles à auditer.

Récapitulatif express

  • New-FsrmQuota -Path 'D:\X' -Size 1.48GB : marche, arrondi automatique.
  • [uint64][math]::Floor(1.48 * 1GB) : contrôle strict du plancher.
  • Point décimal obligatoire (1.48, pas 1,48).
  • Unités binaires : 1GB=230 octets.
  • Utilisez des templates pour la cohérence à grande échelle.
PowerShell
PowerShell Administration système Windows Server FSRM Quotas
Sommaire