Bandbreitenkontrolle für Windows-Updates mit PowerShell meistern

Haupterkenntnisse

• Mit dem Skript können IT-Experten Bandbreitenbeschränkungen für Windows- und Microsoft Store-Updates festlegen.
• Es verwendet PowerShell, um die Windows-Registrierungseinstellungen zur Steuerung des Update-Verkehrs zu ändern.
• Umgebungsvariablen können das Verhalten des Skripts beeinflussen, wenn sie bereits für Bandbreitenbegrenzungen festgelegt wurden.
• Das Skript enthält eine Fehlerbehandlung, um sicherzustellen, dass die Benutzer die erforderlichen Geschwindigkeitsbegrenzungen angeben.
• Die Bandbreitengrenzen werden mit den Parametern BackgroundSpeed und ForegroundSpeed festgelegt.
• Es wird eine Berechtigungsprüfung durchgeführt, um sicherzustellen, dass das Skript mit Administratorrechten ausgeführt wird.
• Das Skript bietet eine flexiblere und automatisierbare Alternative zu manuellen Gruppenrichtlinieneinstellungen.
• Ein angemessenes Bandbreitenmanagement ist entscheidend, um eine Überlastung des Netzes zu vermeiden und den effizienten Betrieb kritischer Anwendungen zu gewährleisten.
• Das Skript sollte in einer kontrollierten Umgebung getestet werden, bevor es in großem Umfang eingesetzt wird.

Die effektive Verwaltung der Netzwerkbandbreite ist ein wichtiger Aspekt der IT-Infrastrukturverwaltung, insbesondere in Umgebungen, in denen Ressourcen gemeinsam genutzt werden und die Netzwerkleistung von größter Bedeutung ist. Mit dem zunehmenden Datenvolumen, das bei Systemaktualisierungen oder bei der Nutzung von Cloud-basierten Diensten übertragen wird, wird die Kontrolle der Bandbreitennutzung für die Aufrechterhaltung der Netzwerkstabilität und -effizienz unerlässlich.

Hintergrund

Das vorgestellte PowerShell-Skript spielt in diesem Zusammenhang eine wichtige Rolle. Es bietet IT-Experten und Managed Service Providern (MSPs) eine Lösung zur Begrenzung der Bandbreitennutzung für Windows-Updates und Microsoft Store-Updates auf Geräten. Diese Funktionalität ist besonders wichtig für Unternehmen, die mit Bandbreitenbeschränkungen zu kämpfen haben oder den Netzwerkverkehr für kritische Anwendungen priorisieren müssen. Durch die Kontrolle des Update-Verkehrs können IT-Experten eine Überlastung des Netzwerks verhindern und sicherstellen, dass geschäftskritische Anwendungen die erforderliche Bandbreite erhalten.

Das Skript:

#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 {
    
    
    
}

 

Detailansicht

Das Skript arbeitet in mehreren wichtigen Phasen:

• Parameter-Definition: Zunächst werden zwei Parameter definiert: BackgroundSpeed und ForegroundSpeed. Mit diesen Parametern können die Benutzer Grenzwerte für die Datenübertragungsraten im Hintergrund bzw. im Vordergrund festlegen.
• Überprüfung der Umgebungsvariablen: Das Skript prüft, ob es Umgebungsvariablen gibt, die diese Parameter bereits setzen, um sicherzustellen, dass es keine vorkonfigurierten Einstellungen überschreibt.
• Fehlerbehandlung: Wenn keine Geschwindigkeitsbegrenzungen angegeben werden, gibt das Skript einen Fehler aus und fordert den Benutzer auf, die erforderlichen Parameter einzugeben.
• Funktionen zur Änderung der Registrierung: Die Kernfunktionalität liegt in der Funktion Set-HKProperty, die Windows-Registrierungsschlüssel ändert, um die Bandbreitenbegrenzung durchzusetzen. Es erstellt oder aktualisiert die entsprechenden Registrierungseinträge mit den angegebenen Werten.
• Bandbreitenberechnung: Die Funktion Get-Size interpretiert die vom Benutzer eingegebenen Geschwindigkeitsbegrenzungen und wandelt sie in ein Format um, das von der Registrierung verstanden wird (Kilobytes).
• Ausführungs- und Berechtigungsprüfung: Bevor das Skript Änderungen vornimmt, prüft es, ob es mit administrativen Rechten ausgeführt wird, was für die Änderung von Registrierungseinstellungen erforderlich ist.

Potenzielle Anwendungsfälle

Stellen Sie sich ein Szenario in einer Bildungseinrichtung vor, in der die Netzwerkbandbreite während der Schulzeit knapp bemessen ist. Der IT-Administrator kann dieses Skript verwenden, um die Bandbreite von Windows Update während dieser Zeiten zu begrenzen und so sicherzustellen, dass Online-Bildungsressourcen Priorität erhalten. Nach der Schulzeit können diese Beschränkungen gelockert oder für regelmäßige Aktualisierungen aufgehoben werden.

Vergleiche

Traditionell wurden Bandbreitenbeschränkungen für Windows-Updates entweder manuell über den Gruppenrichtlinien-Editor oder über Software von Drittanbietern verwaltet. Dieses Skript bietet einen direkteren und skriptfähigen Ansatz, der eine Automatisierung und Integration in größere IT-Management-Workflows ermöglicht.

FAQs

• Wie unterscheidet sich dieses Skript von der Verwendung von Gruppenrichtlinien?
  Das Skript bietet einen flexibleren und automatisierbaren Ansatz im Vergleich zu den manuellen Einstellungen in der Gruppenrichtlinie.
• Kann dieses Skript Szenarien mit unbegrenzter Bandbreite bewältigen?
  Ja, wenn Sie den Geschwindigkeitsparameter auf 0 setzen, können Sie die Bandbreite unbegrenzt nutzen.

Auswirkungen

Die Verwendung dieses Skripts kann die Verwaltung der Netzwerkleistung erheblich verbessern. Die falsche Festlegung von Bandbreitenbeschränkungen kann jedoch kritische Aktualisierungen verzögern und die Systeme möglicherweise Sicherheitslücken aussetzen. Daher ist ein ausgewogener Ansatz erforderlich.

Empfehlungen

• Testen Sie das Skript in einer kontrollierten Umgebung, bevor Sie es auf breiter Basis einsetzen.
• Überwachen Sie die Netzwerkleistung und passen Sie die Grenzwerte gegebenenfalls an.
• Berücksichtigen Sie die Auswirkungen auf die Sicherheit, wenn Sie Aktualisierungen verzögern.

Abschließende Überlegungen

In der Welt der verwalteten IT-Dienstleistungen, in der Tools wie NinjaOne umfassende Lösungen anbieten, verbessern Skripte wie dieses die Kontrolle und Flexibilität. Sie ermöglichen es IT-Fachleuten, die Netzwerkleistung an ihre spezifischen Anforderungen anzupassen – ein entscheidender Vorteil in der heutigen schnelllebigen, datengesteuerten Umgebung. Die Integration solcher Skripte in umfassendere IT-Management-Rahmenwerke kann die Effizienz und Effektivität der Verwaltung der IT-Infrastruktur erheblich steigern.