Dominando o controle de largura de banda para atualizações do Windows com o PowerShell

Principais conclusões

• O script permite que os profissionais de TI definam limites de largura de banda para atualizações do Windows e da Microsoft Store.
• Ele usa o PowerShell para modificar as configurações do Registro do Windows para controlar o tráfego de atualizações.
• As variáveis de ambiente podem influenciar o comportamento do script se já estiverem definidas para limites de largura de banda.
• O script inclui tratamento de erros para garantir que os usuários especifiquem os limites de velocidade necessários.
• Os limites de largura de banda são definidos usando os parâmetros BackgroundSpeed e ForegroundSpeed.
• É realizada uma verificação de privilégios para garantir que o script seja executado com direitos administrativos.
• Ele oferece uma alternativa mais flexível e automatizável às configurações manuais da Política de Grupo.
• O gerenciamento adequado da largura de banda é fundamental para evitar o congestionamento da rede e garantir a execução eficiente de aplicativos essenciais.
• O script deve ser testado em um ambiente controlado antes da implementação generalizada.

O gerenciamento eficaz da largura de banda da rede é um aspecto essencial do gerenciamento da infraestrutura de TI, principalmente em ambientes em que os recursos são compartilhados e o desempenho da rede é fundamental. Com o aumento do volume de dados transferidos durante as atualizações do sistema ou durante o uso de serviços baseados em nuvem, o controle do uso da largura de banda torna-se essencial para manter a estabilidade e a eficiência da rede.

Histórico

O script do PowerShell que estamos discutindo desempenha um papel fundamental nesse contexto. Ele oferece uma solução para que os profissionais de TI e os provedores de serviços gerenciados (MSPs) limitem o uso da largura de banda para atualizações do Windows e da Microsoft Store nos dispositivos. Essa funcionalidade é particularmente importante para organizações que enfrentam limitações de largura de banda ou que precisam priorizar o tráfego de rede para aplicativos essenciais. Ao controlar o tráfego de atualizações, os profissionais de TI podem evitar o congestionamento da rede e garantir que os aplicativos essenciais aos negócios obtenham a largura de banda necessária.

O roteiro:

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

Detalhamento

O script funciona em vários estágios principais:

• Definição do parâmetro: Ele começa definindo dois parâmetros: BackgroundSpeed e ForegroundSpeed. Esses parâmetros permitem que os usuários definam limites para as taxas de transferência de dados em segundo plano e em primeiro plano, respectivamente.
• Verificação de variável de ambiente: O script verifica as variáveis de ambiente existentes que já podem definir esses parâmetros, garantindo que não substitua as configurações pré-configuradas.
• Tratamento de erros: Se nenhum limite de velocidade for fornecido, o script emitirá um erro, solicitando que o usuário insira os parâmetros necessários.
• Funções de modificação do registro: A funcionalidade principal está na função Set-HKProperty, que modifica as chaves do Registro do Windows para impor os limites de largura de banda. Ele cria ou atualiza as entradas de registro relevantes com os valores especificados.
• Cálculo da largura de banda: A função Get-Size interpreta os limites de velocidade inseridos pelo usuário, convertendo-os em um formato compreendido pelo registro (kilobytes).
• Execução e verificação de privilégios: Antes de aplicar qualquer alteração, o script verifica se está sendo executado com privilégios administrativos, o que é necessário para modificar as configurações do registro.

Casos de uso em potencial

Considere um cenário em uma instituição de ensino em que a largura de banda da rede é um prêmio durante o horário escolar. O administrador de TI pode usar esse script para limitar a largura de banda do Windows Update durante esse horário, garantindo que os recursos educacionais on-line tenham prioridade. Após o horário escolar, essas limitações podem ser relaxadas ou removidas para atualizações regulares.

Comparações

Tradicionalmente, os limites de largura de banda para atualizações do Windows eram gerenciados manualmente por meio do Group Policy Editor ou por software de terceiros. Esse script oferece uma abordagem mais direta e com script, permitindo a automação e a integração em fluxos de trabalho maiores de gerenciamento de TI.

Implicações

O uso desse script pode melhorar muito o gerenciamento do desempenho da rede. No entanto, a configuração incorreta dos limites de largura de banda pode atrasar atualizações críticas, expondo os sistemas a vulnerabilidades de segurança. Portanto, é necessária uma abordagem equilibrada.

Recomendações

• Teste o script em um ambiente controlado antes de implementá-lo amplamente.
• Monitore o desempenho da rede e ajuste os limites conforme necessário.
• Tenha em mente as implicações de segurança ao adiar as atualizações.

Considerações finais

No mundo dos serviços gerenciados de TI, em que ferramentas como o NinjaOne oferecem soluções abrangentes, scripts como esse aumentam o controle e a flexibilidade. Eles permitem que os profissionais de TI adaptem o desempenho da rede às suas necessidades específicas, uma vantagem essencial no atual ambiente acelerado e orientado por dados. A integração desses scripts em estruturas mais amplas de gerenciamento de TI pode aumentar significativamente a eficiência e a eficácia do gerenciamento da infraestrutura de TI.