Comment effectuer des tests de vitesse Internet automatisés avec PowerShell

Maintenir une performance optimale du réseau est crucial dans le monde de l’informatique. L’un des aspects essentiels est de veiller à ce que la vitesse Internet réponde constamment aux normes requises. Les professionnels de l’informatique et les fournisseurs de services gérés (MSP) ont besoin de méthodes fiables pour mesurer et vérifier ces vitesses.

Un script PowerShell qui automatise ce processus permet de gagner du temps et de garantir l’exactitude et la mise à jour des informations. Cet article présente un script détaillé conçu pour exécuter un test de vitesse Internet en utilisant le CLI d’Ookla et stocker les résultats dans un champ personnalisé.

Contexte

Le script s’appuie sur le CLI d’Ookla pour effectuer des tests de vitesse Internet sur les appareils Windows, ce qui le rend très utile pour les professionnels de l’informatique et les entreprises MSP. Ce script répond à un défi courant : tester et vérifier la vitesse Internet sur plusieurs appareils sans provoquer de congestion du réseau. En randomisant l’heure de début des tests dans une fenêtre de 60 minutes, il garantit que les tests sont espacés, ce qui réduit la probabilité de tests effectués simultanément.

Le script PowerShell :

#Requires -Version 3.0

<#
.SYNOPSIS
    Runs an internet speed test using Ookla Cli on the target windows device and saves the results to a Multi-Line Custom Field.
.DESCRIPTION
    Runs an internet speed test using Ookla Cli on the target windows device and saves the results to a Multi-Line Custom Field.
    Script will pick a random time slot from 0 to 60 minutes to run the speed test.
    This lessens the likely hood that multiple devices are testing at the same time.

    The default custom field: speedtest
.OUTPUTS
    None
.NOTES
    Minimum OS Architecture Supported: Windows 7, Windows Server 2012
    Minimum PowerShell Version: 3.0
    Release Notes: Renamed script and added Script Variable support
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).
.COMPONENT
    Utility
#>
[CmdletBinding()]
param (
    [Parameter()]
    [string]$CustomField = "speedtest",
    [Parameter()]
    [switch]$SkipSleep = [System.Convert]::ToBoolean($env:skipRandomSleepTime)
)
begin {
    if ($env:customFieldName -and $env:customFieldName -notlike "null") { $CustomField = $env:customFieldName }
    # add TLS 1.2 and SSL3 to allow Invoke-WebRequest to work under older PowerShell versions
    if ($PSVersionTable.PSVersion.Major -eq 2) {
        Write-Host "Requires at least PowerShell 3.0 to run."
        exit 1
    }
    else {
        try {
            $TLS12Protocol = [System.Net.SecurityProtocolType] 'Ssl3 , Tls12, Tls11'
            [System.Net.ServicePointManager]::SecurityProtocol = $TLS12Protocol
        }
        catch {
            Write-Host "Failed to set SecurityProtocol to Tls 1.2, Tls1.1, and Ssl3"
        }
    }
    $CurrentPath = Get-Item -Path ".\"
}
process {
    # Random delay from 0 to 60 minutes in 2 minute time slots
    $MaximumDelay = 60
    $TimeChunks = 2
    $Parts = ($MaximumDelay / $TimeChunks) + 1
    $RandomNumber = Get-Random -Minimum 0 -Maximum $Parts
    $Minutes = $RandomNumber * $TimeChunks
    if (-not $SkipSleep) {
        Start-Sleep -Seconds $($Minutes * 60)
    }

    # Get latest version of speedtest cli
    try {
        $Cli = Invoke-WebRequest -Uri "https://www.speedtest.net/apps/cli" -UseBasicParsing
    }
    catch {
        Write-Host "Failed to query https://www.speedtest.net/apps/cli for speed test cli zip."
        exit 1
    }
    
    # Get the download link
    $Url = $Cli.Links | Where-Object { $_.href -like "*win64*" } | Select-Object -ExpandProperty href
    # Build the URL and destination path
    $InvokeSplat = @{
        Uri     = $Url
        OutFile = Join-Path -Path $CurrentPath -ChildPath $($Url | Split-Path -Leaf)
    }
    # Download the speedtest cli zip
    try {
        Invoke-WebRequest @InvokeSplat -UseBasicParsing
    }
    catch {
        Write-Host "Failed to download speed test cli zip from $Url"
        exit 1
    }
    
    # Build the path to speedtest.exe
    $ExePath = Join-Path -Path $CurrentPath -ChildPath "speedtest.exe"
    $MdPath = Join-Path -Path $CurrentPath -ChildPath "speedtest.md"

    if ($(Get-Command -Name "Expand-Archive" -ErrorAction SilentlyContinue).Count) {
        Expand-Archive -Path $InvokeSplat["OutFile"] -DestinationPath $CurrentPath
    }
    else {
        # Unzip the speedtest cli zip
        Add-Type -AssemblyName System.IO.Compression.FileSystem
        if ((Test-Path -Path $ExePath)) {
            Remove-Item -Path $ExePath, $MdPath -Force -Confirm:$false -ErrorAction Stop
        }
        [System.IO.Compression.ZipFile]::ExtractToDirectory($InvokeSplat["OutFile"], $CurrentPath)
    }

    $JsonOutput = if ($(Test-Path -Path $ExePath -ErrorAction SilentlyContinue)) {
        # Run speed test and output in a json format
        try {
            Invoke-Command -ScriptBlock {
                & .\speedtest.exe --accept-license --accept-gdpr --format=json
                if (0 -ne $LASTEXITCODE) {
                    Write-Error -Message "Failed to run speedtest.exe."
                }
            }
        }
        catch {
            Remove-Item -Path $ExePath, $MdPath, $InvokeSplat["OutFile"] -Force -Confirm:$false
            Write-Error -Message "Failed to run speedtest.exe."
            exit 1
        }
    }

    if ($JsonOutput) {
        # Convert from Json to PSCustomObject
        $Output = $JsonOutput | ConvertFrom-Json
        # Output the results
        $Results = [PSCustomObject]@{
            Date       = $Output.timestamp | Get-Date
            ISP        = $Output.isp
            Down       = "$([System.Math]::Round($Output.download.bandwidth * 8 / 1MB,0)) Mbps"
            Up         = "$([System.Math]::Round($Output.upload.bandwidth * 8 / 1MB,0)) Mbps"
            ResultUrl  = $Output.result.url
            PacketLoss = $Output.packetLoss
            Jitter     = $Output.ping.jitter
            Latency    = $Output.ping.latency
            Low        = $Output.ping.low
            High       = $Output.ping.high
        } | Out-String
        $Results | Write-Host
        Ninja-Property-Set -Name $CustomField -Value $Results
    }
    Remove-Item -Path $ExePath, $MdPath, $InvokeSplat["OutFile"] -Force -Confirm:$false
    exit 0
}
end {
    
    
    
}

 

Description détaillée

Le script effectue plusieurs tâches essentielles :

1. Initialisation des paramètres : Définit les paramètres par défaut et vérifie les variables d’environnement.
2. Configuration TLS: Veille à ce que les protocoles de sécurité appropriés soient définis pour les anciennes versions de PowerShell.
3. Délai aléatoire: Introduit un délai aléatoire avant l’exécution du test de vitesse pour éviter la congestion du réseau.
4. Téléchargement du CLI Speedtest: Télécharge la dernière version du CLI d’Ookla.
5. Exécution de test de vitesse: Exécute le test de vitesse et capture les résultats au format JSON.
6. Analyse et stockage des résultats: Convertit les résultats JSON dans un format lisible et les stocke dans un champ personnalisé.

Description étape par étape

1. Initialisation des paramètres Le script commence par définir les paramètres. $CustomField indique où les résultats seront stockés, et $SkipSleep est un interrupteur qui permet de sauter le délai aléatoire.
2. Configuration TLS Cette section permet de s’assurer que les protocoles TLS appropriés sont activés, ce qui est nécessaire pour sécuriser les requêtes web.
3. Délai aléatoire Pour éviter la congestion du réseau, le script attend un délai aléatoire compris entre 0 et 60 minutes avant d’exécuter le test de vitesse.
4. Speedtest CLI Download Cette partie télécharge et extrait la dernière version du CLI d’Ookla.
5. Exécution de test de vitesse Le script exécute le test de vitesse et affiche les résultats au format JSON.
6. Analyse et stockage des résultats Les résultats sont analysés et stockés dans un champ personnalisé.

Cas d’utilisation potentiels

Imaginez une entreprise MSP qui gère plusieurs réseaux de clients. En déployant ce script sur les machines des clients, l’entreprise MSP peut recueillir des données sur la vitesse Internet sans intervention manuelle. Par exemple, si un client signale des lenteurs intermittentes sur l’internet, l’entreprise MSP peut examiner l’historique des résultats des tests de vitesse afin d’identifier des schémas et de résoudre le problème plus efficacement.

Comparaisons

D’autres méthodes pour tester la vitesse de l’internet peuvent inclure l’utilisation d’outils basés sur le web ou d’applications autonomes. Bien qu’elles puissent être efficaces, elles manquent d’automatisation et de stockage centralisé des données. Ce script PowerShell offre une solution optimale et automatisée qui s’intègre en toute simplicité aux systèmes existants, offrant un avantage significatif en termes d’efficacité et de gestion des données.

FAQ

Q1 : Pourquoi utiliser un délai aléatoire ?

A1 : Le délai aléatoire permet d’éviter que plusieurs appareils n’effectuent le test de vitesse simultanément, ce qui pourrait fausser les résultats et créer une congestion du réseau.

Q2 : Ce script peut-il être exécuté avec n’importe quelle version de PowerShell ?

A2 : Le script nécessite au moins PowerShell 3.0 en raison de certaines dépendances de cmdlets et de configurations TLS.

Q3 : Que faire si le téléchargement de la CLI d’Ookla échoue ?

A3 : Le script comprend une gestion des erreurs qui permet de quitter le système de manière élégante et de fournir un message d’erreur en cas d’échec du téléchargement.

Implications

Un test précis de la vitesse de l’internet peut aider à identifier les problèmes potentiels du réseau, y compris les anomalies liées à la sécurité, telles que les baisses de vitesse inattendues qui pourraient indiquer une interférence du réseau ou une utilisation non autorisée. Une surveillance régulière à l’aide de ce script peut fournir des informations sur les performances du réseau et contribuer à maintenir des normes de sécurité solides.

Recommandations

1. Planification régulière: Programmez l’exécution du script à intervalles réguliers pour effectuer une surveillance continue.
2. Examen des résultats: Examinez périodiquement les données collectées afin d’identifier les tendances et de résoudre les problèmes éventuels.
3. Stockage sécurisé: Veillez à ce que les résultats soient conservés en toute sécurité afin d’éviter tout accès non autorisé.

Conclusion

L’utilisation de ce script PowerShell pour effectuer des tests de vitesse Internet constitue un outil puissant pour les professionnels de l’informatique et les MSP. En automatisant le processus et en stockant les résultats dans un champ personnalisé, il simplifie la surveillance des performances du réseau. NinjaOne peut encore améliorer cette capacité en intégrant le script dans sa suite d’outils, fournissant ainsi une plateforme centralisée pour la gestion et l’analyse des données de performance du réseau.