Umbenennen von Windows-Rechnern mit PowerShell

Haupterkenntnisse

• Flexibilität von PowerShell-Skripten: Das Skript veranschaulicht die Leistungsfähigkeit und Flexibilität von PowerShell bei der Verwaltung von Computereinstellungen und unterstreicht die Bedeutung von PowerShell in der modernen IT-Administration.
• Einfaches Umbenennen von Computern: Hervorzuheben ist die Einfachheit, mit der IT-Experten sowohl domänenverbundene als auch nicht domänenverbundene Computer umbenennen können.
• Domänenadministrator-Zugangsdaten: Betont die Notwendigkeit von Domänenadministrator-Zugangsdaten für die Umbenennung von domänenverbundenen Rechnern, sofern dies nicht von einem Domänenadministrator ausgeführt wird.
• Automatische Neustart-Option: Das Skript enthält eine optionale Funktion zum automatischen Neustart, die für das Wirksamwerden der Änderungen unerlässlich ist.
• Sicherheitserwägungen: Unterstreicht die Bedeutung eines sicheren Umgangs mit Anmeldeinformationen in Skripten, wie die Umwandlung von Klartextpasswörtern in sichere Zeichenfolgen zeigt.
• Fehlerbehandlung und Validierung: Das Skript enthält eine robuste Fehlerbehandlung und Validierung, die eine sichere und zuverlässige Ausführung gewährleistet.
• Anwendung in der realen Welt: Veranschaulicht praktische Anwendungsfälle, insbesondere für IT-Fachleute und Managed Service Provider (MSPs), um die Computerverwaltung zu optimieren.

Die effiziente Verwaltung der IT-Infrastruktur ist für den reibungslosen Betrieb moderner Unternehmen von zentraler Bedeutung. Neben zahlreichen anderen Aufgaben kann die Umbenennung von Computern, insbesondere in einer Domänenumgebung, für die Aufrechterhaltung der Systemorganisation, die Einhaltung von Namenskonventionen und die Gewährleistung von Sicherheitsprotokollen entscheidend sein. PowerShell-Skripts haben sich als leistungsstarke Tools zur Automatisierung solcher Aufgaben erwiesen und bieten Präzision, Geschwindigkeit und Skalierbarkeit.

Hintergrund

Das vorgestellte PowerShell-Skript wurde entwickelt, um den Prozess der Umbenennung von Computern zu automatisieren. Diese Methode ist besonders wertvoll für IT-Experten und Managed Service Provider (MSPs), die große Netzwerke mit zahlreichen Rechnern verwalten. Sie erfüllt den Bedarf an einem konsistenten und fehlerfreien Ansatz für die Umbenennung, was in Umgebungen, in denen Computernamen oft mit bestimmten Rollen, Abteilungen oder Nutzungsrichtlinien verknüpft sind, von entscheidender Bedeutung ist.

Das Skript:

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

 

Detailansicht

Dieses Skript automatisiert den Prozess der Umbenennung von Windows-Computern, die entweder einer Domäne angeschlossen sind oder nicht. Hier ist eine schrittweise Erklärung:

• Parameter-Deklaration: Das Skript beginnt mit der Angabe von Parametern wie NewName, DomainUser, DomainPassword und Reboot. Diese Eingaben bestimmen den neuen Computernamen, die Domänenzugangsdaten und ob der Computer nach der Umbenennung neu gestartet werden soll.
• Initiale Kontrollen und Handhabung von Zugangsdaten: Es prüft auf Umgebungsvariablen und wandelt Klartextpasswörter in sichere Zeichenfolgen um. Für Domänenvorgänge wandelt es Benutzerzugangsdaten in ein PowerShell-Zugangsdatenobjekt um.
• Funktionen: Es sind mehrere Funktionen definiert, um zu prüfen, ob das Skript mit erhöhten Rechten ausgeführt wird, ob der Computer Teil einer Domäne ist, ob es als Systembenutzer ausgeführt wird und ob der Benutzer ein Domänenadministrator ist.
• Validierung: Das Skript überprüft, ob ein neuer Name angegeben wurde und ob er sich vom aktuellen Namen unterscheidet. Außerdem werden die administrativen Rechte und ggf. die Domänenkonnektivität überprüft.
• Ausführung: Wenn alle Prüfungen erfolgreich sind, wird das Cmdlet “ Rename-Computer“ mit den entsprechenden Parametern aufgerufen. Dieses Cmdlet ist der Hauptbefehl, der den Umbenennungsprozess ausführt.
• Handhabung des Neustarts: Wenn der Schalter -Reboot verwendet wird, plant das Skript einen Neustart des Systems in 5 Minuten, um die Änderungen zu übernehmen.

Potenzielle Anwendungsfälle

Stellen Sie sich vor, ein MSP verwaltet ein Netzwerk für ein großes Unternehmen, das seine Abteilungen umstrukturiert. Der MSP verwendet dieses Skript, um Computer im gesamten Netzwerk effizient umzubenennen, damit sie die neue Abteilungsstruktur widerspiegeln, was Konsistenz gewährleistet und den manuellen Aufwand reduziert.

Vergleiche

Herkömmliche Methoden zur Umbenennung von Computern erfordern oft einen manuellen Eingriff, entweder über die Systemeigenschaften oder über Domänencontroller-Tools. Dieses Skript bietet einen schlankeren und fehlerresistenteren Ansatz, der besonders nützlich ist, wenn mehrere Rechner betroffen sind.

FAQs

Q1: Kann dieses Skript Computer in großen Mengen umbenennen?
A: Ja, allerdings müssen Sie ihn möglicherweise so ändern, dass er eine Liste von Computern und deren neuen Namen durchläuft.

Q2: Ist die Verwendung von Klartextkennwörtern im Skript sicher?
A: Das Skript wandelt Passwörter im Klartext in sichere Zeichenfolgen um und erhöht so die Sicherheit. Es wird jedoch empfohlen, mit Zugangsdaten vorsichtig umzugehen.

Q3: Benötige ich Administratorrechte, um dieses Skript auszuführen?
A: Ja, es sind Administratorrechte erforderlich, insbesondere für die Umbenennung von Computern, die einer Domäne angehören.

Auswirkungen

Dieses Skript vereinfacht zwar eine Routineaufgabe, aber eine unsachgemäße Verwendung kann zu Namenskonflikten, Netzwerkproblemen oder Sicherheitslücken führen. Es ist wichtig, Umbenennungsstrategien zu planen und regelmäßig zu prüfen, um sicherzustellen, dass sie mit den Unternehmensrichtlinien und den Normen der IT-Infrastruktur übereinstimmen.

Empfehlungen

• Gründlich testen: Führen Sie das Skript in einer Testumgebung aus, bevor Sie es in der Produktion einsetzen.
• Sichere Zugangsdaten: Handhaben und speichern Sie Zugangsdaten sicher, vorzugsweise mit verschlüsselten Methoden.
• Dokumentieren von Änderungen: Führen Sie Aufzeichnungen über Änderungen zur Fehlerbehebung und zu Prüfzwecken.

Abschließende Überlegungen

Im Bereich des IT-Managements bieten Tools wie NinjaOne umfassende Lösungen für die Verwaltung und Automatisierung von IT-Aufgaben. Die Integration solcher Skripte in ein breiteres Management-Framework wie NinjaOne kann die Effizienz steigern, Fehler reduzieren und eine bessere Kontrolle über IT-Umgebungen ermöglichen. Durch die Nutzung der Vorteile der Automatisierung und der zentralen Verwaltung können sich IT-Experten auf strategische Initiativen statt auf Routineaufgaben konzentrieren.