Comment renommer les ordinateurs Windows avec PowerShell

Principaux points à retenir

• Flexibilité des scripts PowerShell: Ce script illustre la puissance et la flexibilité de PowerShell dans la gestion des paramètres d’ordinateur, soulignant l’importance de PowerShell dans l’administration informatique moderne.
• Facilité de changement du nom des ordinateurs: Souligne la facilité avec laquelle les professionnels de l’informatique peuvent renommer les ordinateurs appartenant ou non à un domaine.
• Identifiants d’administrateur de domaine: Souligne la nécessité de disposer d’identifiants d’administrateur de domaine pour renommer des machines reliées à un domaine, à moins qu’elles ne soient exécutées par un administrateur de domaine.
• Option de redémarrage automatique: Le script comprend une fonction optionnelle de redémarrage automatique, qui est cruciale pour que les changements aient lieu.
• Questions relatives à la sécurité : Souligne l’importance d’un traitement sécurisé des informations d’identification dans les scripts, comme le montre la conversion des mots de passe en texte clair en chaînes de caractères sécurisées.
• Traitement des erreurs et validation: Le script intègre une gestion des erreurs et une vérification performantes, garantissant une exécution sûre et fiable.
• Application dans le monde réel: Illustre des cas d’utilisation pratiques, en particulier pour les professionnels de l’informatique et les fournisseurs de services gérés (MSP), afin de simplifier les tâches de gestion informatique.

La gestion efficace de l’infrastructure informatique est essentielle au bon fonctionnement des entreprises modernes. Parmi de nombreuses tâches, renommer les ordinateurs, en particulier dans un environnement de domaine, peut s’avérer crucial pour maintenir l’organisation du système, respecter les conventions de dénomination et garantir les protocoles de sécurité. Les scripts PowerShell se sont imposés comme des outils puissants pour automatiser ces tâches, en offrant précision, rapidité et évolutivité.

Contexte

Le script PowerShell que nous explorons est conçu pour renommer les ordinateurs de façon automatisée. Cette capacité est particulièrement précieuse pour les professionnels de l’informatique et les fournisseurs de services gérés (MSP) qui gèrent de grands réseaux avec de nombreuses machines. Il répond au besoin d’une approche cohérente et sans erreur du renommage, ce qui est crucial dans les environnements où les noms des ordinateurs sont souvent alignés sur des rôles spécifiques, des départements ou des politiques d’utilisation.

Le script :

#Requires -Version 5.1

<#
.SYNOPSIS
    Renames either domain-joined or non-domain-joined machines. Requires a Domain Admin's username and password for domain-joined computers, unless run as a Domain Admin.
.DESCRIPTION
    Renames either domain-joined or non-domain-joined machines. Requires a Domain Admin's username and password for domain-joined computers, unless run as a Domain Admin.
.EXAMPLE
    -NewName "ReplaceWithNewName"

    WARNING: The changes will take effect after you restart the computer KYLE-WIN10-TEST.

    HasSucceeded OldComputerName           NewComputerName          
    ------------ ---------------           ---------------          
    True         KYLE-WIN10-TEST           ReplaceWithNewName               



    WARNING: This script takes effect after a reboot. Use -Reboot to have this script reboot for you.

PARAMETER: -DomainUser "UsernameForDomainAdmin" -DomainPassword "SuperSecretPassword1"
    Domain Joined machines require a domain admins creds when not ran as a Domain Admin (System is not a Domain Admin).

PARAMETER: -Reboot
    Reboots the computer 5 minutes after the script is ran.
.EXAMPLE
    -NewName "ReplaceWithNewName" -Reboot

    This is a domain joined machine. Testing for secure domain connection...
    WARNING: The changes will take effect after you restart the computer KYLE-WIN10-TEST.

    HasSucceeded OldComputerName           NewComputerName          
    ------------ ---------------           ---------------          
    True         KYLE-WIN10-TEST           ReplaceWithNewName               

    WARNING: Reboot specified scheduling reboot for 06/13/2023 12:09:53...

.OUTPUTS
    None
.NOTES
    OS: Win 10+, Server 2016+
    Release: 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]$NewName,
    [Parameter()]
    [String]$DomainUser,
    [Parameter()]
    [String]$DomainPassword,
    [Parameter()]
    [Switch]$Reboot = [System.Convert]::ToBoolean($env:reboot)
)

begin {
    # If script forms are used overwrite the params with those values.
    if ($env:newComputerName -and $env:newComputerName -notlike "null") { $NewName = $env:newComputerName }
    if ($env:domainAdminUsername -and $env:domainAdminUsername -notlike "null") { $DomainUser = $env:domainAdminUsername }
    if ($env:domainAdminPassword -and $env:domainAdminPassword -notlike "null") { 
        $DomainPassword = $env:domainAdminPassword
        # We should overwrite the environmental variable with a secure string 
        $env:domainAdminPassword = $env:domainAdminPassword | ConvertTo-SecureString -AsPlainText -Force 
    }

    # Converts the username and password into a powershell credential object
    if ($DomainUser -and $DomainPassword) {
        $Credential = New-Object System.Management.Automation.PsCredential("$DomainUser", $($DomainPassword | ConvertTo-SecureString -AsPlainText -Force))
    }

    # If a domain password was given we should overwrite it with a secure string
    if ($DomainPassword) {
        $DomainPassword = $DomainPassword | ConvertTo-SecureString -AsPlainText -Force
    }

    # Checks if script is running as an elevated user
    function Test-IsElevated {
        $id = [System.Security.Principal.WindowsIdentity]::GetCurrent()
        $p = New-Object System.Security.Principal.WindowsPrincipal($id)
        $p.IsInRole([System.Security.Principal.WindowsBuiltInRole]::Administrator)
    }

    # Check if machine is domain joined
    function Test-IsDomainJoined {
        return $(Get-CimInstance -Class Win32_ComputerSystem).PartOfDomain
    }

    # Check if script is running as System
    function Test-IsSystem {
        $id = [System.Security.Principal.WindowsIdentity]::GetCurrent()
        return $id.Name -like "NT AUTHORITY*" -or $id.IsSystem
    }

    # Check if script is running as a domain admin
    function Test-IsDomainAdmin {
        $id = [System.Security.Principal.WindowsIdentity]::GetCurrent()
        $p = New-Object System.Security.Principal.WindowsPrincipal($id)
        return $p.IsInRole("Domain Admins")
    }

    # Double check that this script has something to do.
    if ($NewName -eq $env:computername) {
        Write-Error "[Error] New name is the same as the current hostname."
        exit 1
    }

    # Error out if not provided with a new name
    if (-not $Newname) {
        Write-Error "[Error] Please specify a name with the NewName parameter!"
        exit 1
    }
}
process {
    # If not running as the system user script needs to be running as an elevated user.
    if (-not (Test-IsElevated) -and -not (Test-IsSystem)) {
        Write-Error -Message "Access Denied. Please run with Administrator privileges."
        exit 1
    }

    # Warn end-users if theyre giving the computer too long of a name.
    if ($NewName.Length -gt 15) {
        Write-Warning -Message "The New Computer Name $NewName exceeds 15 characters! In some instances you may only see the first 15 characters."
    }

    # Preparing Splat
    $ArgumentList = @{
        "ComputerName" = $env:computername
        "Force"        = $True
        "NewName"      = $NewName
        "PassThru"     = $True
    }

    # If it's domain joined we'll have to check a couple things to make sure this is possible
    if (Test-IsDomainJoined) {
        Write-Host -Object "This is a domain joined machine. Testing for secure domain connection..."

        # The domain controller will need to be reachable for the rename to apply
        if (-not (Test-ComputerSecureChannel -ErrorAction Ignore)) {
            Write-Error -Message "[Error] A secure connection to the domain controller cannot be established!
            Please ensure the domain is reachable and there are no machines with identical names!"
            exit 1
        }

        # Domain joined machines require a domain admin to change the name
        if (-not $Credential -and -not (Test-IsDomainAdmin)) {
            Write-Error -Message "[Error] The -DomainUser and -DomainPassword parameter is missing. 
            The username and password for a domain admin is required when not ran as a Domain Admin for domain joined machines!"
            exit 1
        }

        # Adding credentials to the splat
        if ($Credential) {
            $ArgumentList["DomainCredential"] = $Credential
        }
    }

    # Saving the results to check later
    $Result = Rename-Computer @ArgumentList

    # Letting the end-user know the result
    $Result | Format-Table | Out-String | Write-Host

    # Error out on failure
    if (-not $Result.HasSucceeded) {
        Write-Error -Message "[Error] Failed to rename computer!"
        exit 1
    }

    # If a reboot was specified schedule it for 5 minutes from now.
    if ($Reboot) {
        Write-Warning -Message "Reboot specified scheduling reboot for $((Get-Date).AddMinutes(5))..."
        Start-Process -FilePath "cmd.exe" -ArgumentList "/C shutdown.exe /r /t 300"
    }
    else {
        Write-Warning -Message "This script takes effect after a reboot. Use -Reboot to have this script reboot for you."
    }
    exit 0
}
end {
    
    
    
}

 

Description détaillée

Ce script automatise le processus de renommage des ordinateurs Windows, qu’ils soient liés ou non à un domaine. En voici la description étape par étape :

• Déclaration des paramètres: Le script commence par déclarer des paramètres tels que NewName, DomainUser, DomainPassword et Reboot. Ces entrées déterminent le nouveau nom de l’ordinateur, les informations d’identification du domaine et la nécessité ou non de redémarrer la machine après le changement de nom.
• Vérifications initiales et traitement des identifiants: Il vérifie les variables d’environnement et convertit les mots de passe en clair en chaînes de caractères sécurisées. Pour les opérations de domaine, il transforme les informations d’identification de l’utilisateur en un objet ‘credential’ de PowerShell.
• Fonctions: Plusieurs fonctions sont définies pour vérifier si le script s’exécute avec des privilèges élevés, si l’ordinateur fait partie d’un domaine, s’il s’exécute en tant qu’utilisateur système et si l’utilisateur est un administrateur domaine.
• Validation : Le script vérifie qu’un nouveau nom est fourni et qu’il est différent du nom actuel. Il vérifie également les privilèges d’administrateur et la connectivité au domaine, le cas échéant.
• Exécution: Si toutes les vérifications sont bonnes, la cmdlet Rename-Computer est appelée avec les paramètres appropriés. Cette cmdlet est la commande principale qui exécute le processus de renommage.
• Gestion du redémarrage: Si l’option -Reboot est utilisée, le script planifie un redémarrage du système dans 5 minutes pour appliquer les modifications.

Cas d’utilisation potentiels

Imaginez qu’une entreprise MSP gère le réseau d’une grande organisation qui restructure ses services. L’entreprise MSP utilise ce script pour renommer efficacement les ordinateurs à travers le réseau afin de refléter la nouvelle structure départementale, assurant ainsi la conformité et réduisant le travail manuel.

Comparaisons

Les méthodes traditionnelles de renommage des ordinateurs impliquent souvent une intervention manuelle, par le biais des propriétés du système ou des outils du contrôleur de domaine. Ce script offre une approche plus rationnelle et plus résistante aux erreurs, particulièrement utile lorsqu’il s’agit de gérer plusieurs machines.

FAQ

Q1 : Ce script peut-il renommer un grand groupe d’ordinateurs ?
R : Oui, mais vous devrez peut-être le modifier pour qu’il passe en boucle par une liste d’ordinateurs et leurs nouveaux noms.

Q2 : Est-il sûr d’utiliser des mots de passe en texte clair dans le script ?
R : Le script convertit les mots de passe en texte clair en chaînes de caractères sécurisées, ce qui renforce la sécurité. Toutefois, il est recommandé de manipuler les informations d’identification avec prudence.

Q3 : Ai-je besoin de droits d’administrateur pour exécuter ce script ?
R : Oui, des droits d’administrateur sont nécessaires, en particulier pour renommer les ordinateurs reliés à un domaine.

Implications

Bien que ce script simplifie une tâche de routine, une utilisation incorrecte peut entraîner des conflits de noms, des problèmes de réseau ou des vulnérabilités en matière de sécurité. Il est essentiel de planifier et de revoir les stratégies de renommage pour s’assurer qu’elles sont conformes aux stratégies de l’organisation et aux normes de l’infrastructure informatique.

Recommandations

• Effectuer des tests approfondis : Exécutez le script dans un environnement de test avant de le déployer dans la production.
• Sécuriser les informations d’identification: Traitez et stockez les informations d’identification en toute sécurité, de préférence en utilisant des méthodes chiffrées.
• Modifications du document : Conservez un enregistrement des modifications à des fins de dépannage et d’audit.

Conclusion

Dans le domaine de la gestion informatique, des outils comme NinjaOne offrent des solutions complètes pour la gestion et l’automatisation des tâches informatiques. L’intégration de ces scripts dans un cadre de gestion plus large tel que NinjaOne permet d’améliorer l’efficacité, de réduire les erreurs et d’assurer un meilleur contrôle des environnements informatiques. En tirant parti de la puissance de l’automatisation et de la gestion centralisée, les professionnels de l’informatique peuvent se concentrer sur des initiatives stratégiques plutôt que sur des tâches de routine.