Changer les limites de la bande passante pour les mises à jour Windows avec PowerShell

Principaux points à retenir

• Le script permet aux professionnels de l’informatique de définir des limites de bande passante pour les mises à jour de Windows et de Microsoft Store.
• Il utilise PowerShell pour modifier les paramètres du registre Windows afin de contrôler le trafic des mises à jour.
• Les variables d’environnement peuvent influencer le comportement du script si elles ont déjà été définies pour les limites de la bande passante.
• Le script comprend une gestion des erreurs pour s’assurer que les utilisateurs spécifient les limites de vitesse requises.
• Les limites de la bande passante sont définies à l’aide des paramètres BackgroundSpeed et ForegroundSpeed.
• Un contrôle des privilèges est effectué pour s’assurer que le script s’exécute avec des droits d’administrateur.
• Il offre une alternative automatisable et plus flexible que les réglages manuels de la stratégie de groupe.
• Une gestion appropriée de la bande passante est cruciale pour éviter la congestion du réseau et garantir le fonctionnement efficace des applications cruciales.
• Le script doit être testé dans un environnement contrôlé avant d’être implémenté à grande échelle.

La gestion efficace de la bande passante du réseau est un élément essentiel de la gestion de l’infrastructure informatique, en particulier dans les environnements où les ressources sont partagées et où les performances du réseau sont primordiales. Avec l’augmentation du volume de données transférées lors des mises à jour du système ou lors de l’utilisation de services basés sur le cloud, le contrôle de l’utilisation de la bande passante devient essentiel pour maintenir la stabilité et l’efficacité du réseau.

Contexte

Le script PowerShell dont nous parlons joue un rôle essentiel dans ce contexte. Il permet aux professionnels de l’informatique et aux fournisseurs de services gérés (MSP) de limiter l’utilisation de la bande passante pour les mises à jour Windows et les mises à jour du Microsoft Store sur les appareils. Cette fonctionnalité est particulièrement cruciale pour les entreprises qui sont confrontées à des limitations de bande passante ou qui doivent donner la priorité au trafic réseau pour les applications cruciales. En contrôlant le trafic de mise à jour, les professionnels de l’informatique peuvent éviter la congestion du réseau et s’assurer que les applications cruciales de l’entreprise bénéficient de la bande passante nécessaire.

Le script :

#Requires -Version 5.1

<#
.SYNOPSIS
    Limit how much bandwidth a device can consume with updates and microsoft store updates. Please note 5Mbps will set a different speed limit than 5MBps.
.DESCRIPTION
    Limit how much bandwidth a device can consume with updates and microsoft store updates. Please note 5Mbps will set a different speed limit than 5MBps.
.EXAMPLE
    (No Parameters)

    C:ProgramDataNinjaRMMAgentscriptingcustomscript_gen_6.ps1 : No Speed Limit given?
    + CategoryInfo          : NotSpecified: (:) [Write-Error], WriteErrorException
    + FullyQualifiedErrorId : Microsoft.PowerShell.Commands.WriteErrorException,customscript_gen_6.ps1

PARAMETER: -BackgroundSpeed "15Mbps"
    Limits the "background" bandwidth to 15Mbps replace "15Mbps" with your prefered speed limit.
.EXAMPLE
    -BackgroundSpeed "15Mbps"
    
    HKLM:SOFTWAREPoliciesMicrosoftWindowsDeliveryOptimizationDOMaxBackgroundDownloadBandwidth changed from 1920 to 1920

PARAMETER: -ForegroundSpeed "15Mbps"
    Limits the "foreground" bandwidth to 15Mbps replace "15Mbps" with your prefered speed limit.
.EXAMPLE
    -ForegroundSpeed "15Mbps"
    
    HKLM:SOFTWAREPoliciesMicrosoftWindowsDeliveryOptimizationDOMaxForegroundDownloadBandwidth changed from 1920 to 1920

.OUTPUTS
    None
.NOTES
    Minimum OS Architecture Supported: Windows 10
    Release Notes: Initial Release
By using this script, you indicate your acceptance of the following legal terms as well as our Terms of Use at https://www.ninjaone.com/terms-of-use.
    Ownership Rights: NinjaOne owns and will continue to own all right, title, and interest in and to the script (including the copyright). NinjaOne is giving you a limited license to use the script in accordance with these legal terms. 
    Use Limitation: You may only use the script for your legitimate personal or internal business purposes, and you may not share the script with another party. 
    Republication Prohibition: Under no circumstances are you permitted to re-publish the script in any script library or website belonging to or under the control of any other software provider. 
    Warranty Disclaimer: The script is provided “as is” and “as available”, without warranty of any kind. NinjaOne makes no promise or guarantee that the script will be free from defects or that it will meet your specific needs or expectations. 
    Assumption of Risk: Your use of the script is at your own risk. You acknowledge that there are certain inherent risks in using the script, and you understand and assume each of those risks. 
    Waiver and Release: You will not hold NinjaOne responsible for any adverse or unintended consequences resulting from your use of the script, and you waive any legal or equitable rights or remedies you may have against NinjaOne relating to your use of the script. 
    EULA: If you are a NinjaOne customer, your use of the script is subject to the End User License Agreement applicable to you (EULA).
#>

[CmdletBinding()]
param (
    [Parameter()]
    [String]$BackgroundSpeed,
    [Parameter()]
    [String]$ForegroundSpeed
)

begin {

    if ($env:maxBackgroundDownloadSpeed -and $env:maxBackgroundDownloadSpeed -notlike "null") { $BackgroundSpeed = $env:maxBackgroundDownloadSpeed }
    if ($env:maxForegroundDownloadSpeed -and $env:maxForegroundDownloadSpeed -notlike "null") { $ForegroundSpeed = $env:maxForegroundDownloadSpeed }

    if (-not $BackgroundSpeed -and -not $ForegroundSpeed) {
        Write-Error "No Speed Limit given?"
        Exit 1
    }

    function Set-HKProperty {
        param (
            $Path,
            $Name,
            $Value,
            [ValidateSet('DWord', 'QWord', 'String', 'ExpandedString', 'Binary', 'MultiString', 'Unknown')]
            $PropertyType = 'DWord'
        )
        if (-not $(Test-Path -Path $Path)) {
            # Check if path does not exist and create the path
            New-Item -Path $Path -Force | Out-Null
        }
        if ((Get-ItemProperty -Path $Path -Name $Name -ErrorAction SilentlyContinue)) {
            # Update property and print out what it was changed from and changed to
            $CurrentValue = (Get-ItemProperty -Path $Path -Name $Name -ErrorAction SilentlyContinue).$Name
            try {
                Set-ItemProperty -Path $Path -Name $Name -Value $Value -Force -Confirm:$false -ErrorAction Stop | Out-Null
            }
            catch {
                Write-Error "[Error] Unable to Set registry key for $Name please see below error!"
                Write-Error $_
                exit 1
            }
            Write-Host "$Path$Name changed from $CurrentValue to $($(Get-ItemProperty -Path $Path -Name $Name -ErrorAction SilentlyContinue).$Name)"
        }
        else {
            # Create property with value
            try {
                New-ItemProperty -Path $Path -Name $Name -Value $Value -PropertyType $PropertyType -Force -Confirm:$false -ErrorAction Stop | Out-Null
            }
            catch {
                Write-Error "[Error] Unable to Set registry key for $Name please see below error!"
                Write-Error $_
                exit 1
            }
            Write-Host "Set $Path$Name to $($(Get-ItemProperty -Path $Path -Name $Name -ErrorAction SilentlyContinue).$Name)"
        }
    }

    function Get-Size {
        param (
            [string]$String
        )
        if ($String -Like 0) {
            return 0
        }
        switch -casesensitive -regex ($String) {
            'PB|pB' { [int64]$($String -replace '[^d+]+') * 1PB; break }
            'Pb|pb' { [int64]$($String -replace '[^d+]+') * 1PB / 8; break }
            'TB|tB' { [int64]$($String -replace '[^d+]+') * 1TB; break }
            'Tb|tb' { [int64]$($String -replace '[^d+]+') * 1TB / 8; break }
            'GB|gB' { [int64]$($String -replace '[^d+]+') * 1GB; break }
            'Gb|gb' { [int64]$($String -replace '[^d+]+') * 1GB / 8; break }
            'MB|mB' { [int64]$($String -replace '[^d+]+') * 1MB; break }
            'Mb|mb' { [int64]$($String -replace '[^d+]+') * 1MB / 8; break }
            'KB|kB' { [int64]$($String -replace '[^d+]+') * 1KB; break }
            'Kb|kb' { [int64]$($String -replace '[^d+]+') * 1KB / 8; break }
            'B|b' { [int64]$($String -replace '[^d+]+') * 1; break }
            Default { [int64]$($String -replace '[^d+]+') * 1MB / 8 }
        }
    }

    function ConvertTo-Kilobytes {
        param (
            [Parameter(ValueFromPipeline)]
            $Number
        )
        process {
            $Number / 1KB
        }
    }

    function Test-IsElevated {
        $id = [System.Security.Principal.WindowsIdentity]::GetCurrent()
        $p = New-Object System.Security.Principal.WindowsPrincipal($id)
        $p.IsInRole([System.Security.Principal.WindowsBuiltInRole]::Administrator)
    }
}
process {
    if (-not (Test-IsElevated)) {
        Write-Error -Message "Access Denied. Please run with Administrator privileges."
        exit 1
    }

    $Path = "HKLM:SOFTWAREPoliciesMicrosoftWindowsDeliveryOptimization"
    if ($BackgroundSpeed) { Set-HKProperty -Path $Path -Name DOMaxBackgroundDownloadBandwidth -Value $(Get-Size $BackgroundSpeed | ConvertTo-Kilobytes ) }
    if ($ForegroundSpeed) { Set-HKProperty -Path $Path -Name DOMaxForegroundDownloadBandwidth -Value $(Get-Size $ForegroundSpeed | ConvertTo-Kilobytes ) }
}
end {
    
    
    
}

 

Description détaillée

Le script se déroule en plusieurs étapes :

• Définition de paramètres: Il commence par définir deux paramètres – BackgroundSpeed et ForegroundSpeed. Ces paramètres permettent aux utilisateurs de fixer des limites pour les taux de transfert de données en arrière-plan (BackgroundSpeed) et en avant-plan (ForegroundSpeed).
• Vérification des variables d’environnement: Le script vérifie les variables d’environnement existantes qui pourraient déjà définir ces paramètres, afin de s’assurer qu’il n’écrase pas les paramètres préconfigurés.
• Gestion des erreurs: Si aucune limite de vitesse n’est indiquée, le script génère une erreur, invitant l’utilisateur à saisir les paramètres requis.
• Fonctions de modification de registre: La fonctionnalité principale réside dans la fonction Set-HKProperty, qui modifie les clés de registre Windows pour appliquer les limites de la bande passante. Il crée ou met à jour les entrées de registre pertinentes avec les valeurs spécifiées.
• Calcul de la bande passante: La fonction Get-Size interprète les limites de vitesse introduites par l’utilisateur et les convertit dans un format compris par le registre (kilo-octets).
• Exécution et contrôle des privilèges: Avant d’appliquer les modifications, le script vérifie s’il s’exécute avec des droits d’administrateur, ce qui est indispensable pour modifier les paramètres de registre.

Cas d’utilisation potentiels

Prenons l’exemple d’un établissement d’enseignement où la bande passante du réseau est très sollicitée pendant les heures de cours. L’administrateur informatique peut utiliser ce script pour limiter la bande passante de Windows Update pendant ces heures, afin que les ressources éducatives en ligne soient prioritaires. Après les heures de classe, ces limitations peuvent être assouplies ou supprimées pour les mises à jour habituelles.

Comparaisons

Traditionnellement, les limites de bande passante pour les mises à jour de Windows étaient gérées soit manuellement via l’éditeur de stratégie de groupe, soit par l’intermédiaire d’un logiciel tiers. Ce script fournit une approche plus directe et scriptable, permettant l’automatisation et l’intégration dans des flux de travail de gestion informatique.

FAQ

• En quoi ce script diffère-t-il de l’utilisation de la stratégie de groupe ?
  Le script offre une approche plus souple et plus automatisable que les paramètres manuels de la stratégie de groupe.
• Ce script peut-il gérer des situations de bande passante illimitée ?
  Oui, le fait de régler le paramètre de vitesse sur 0 permet une utilisation illimitée de la bande passante.

Implications

L’utilisation de ce script permet d’améliorer considérablement la gestion des performances du réseau. Cependant, une mauvaise définition des limites de la bande passante peut retarder des mises à jour importantes, exposant ainsi les systèmes à des vulnérabilités en matière de sécurité. Une approche équilibrée est donc nécessaire.

Recommandations

• Testez le script dans un environnement contrôlé avant de le déployer à grande échelle.
• Contrôlez les performances du réseau et ajuster les limites si nécessaire.
• Gardez à l’esprit les implications en matière de sécurité lorsque vous retardez les mises à jour.

Conclusion

Dans le monde des services informatiques gérés, où des outils comme NinjaOne offrent des solutions complètes, des scripts comme celui-ci renforcent le contrôle et la flexibilité. Ils permettent aux professionnels de l’informatique d’adapter les performances du réseau à leurs besoins particuliers, ce qui constitue un avantage essentiel dans l’environnement actuel, qui évolue rapidement et est axé sur les données. L’intégration de ces scripts dans la gestion informatique peut considérablement améliorer l’efficacité de la gestion de l’infrastructure informatique.