Como renomear máquinas Windows com o PowerShell

Principais conclusões

• Flexibilidade do script do PowerShell: O script mostra o poder e a flexibilidade do PowerShell no gerenciamento das configurações do computador, enfatizando a importância do PowerShell na administração moderna de TI.
• Facilidade de renomear computadores: Destaca a facilidade com que os profissionais de TI podem renomear computadores com e sem domínio.
• Credenciais de administrador do domínio: Enfatiza a necessidade de credenciais de administrador de domínio para renomear máquinas unidas por domínio, a menos que seja executado por um administrador de domínio.
• Opção de reinicialização automatizada: O script inclui um recurso opcional de reinicialização automática, que é crucial para que as alterações tenham efeito.
• Considerações sobre segurança: Destaca a importância de lidar com credenciais de forma segura em scripts, conforme demonstrado pela conversão de senhas de texto simples em cadeias de caracteres seguras.
• Tratamento de erros e validação: O script incorpora tratamento de erros e validação robustos, garantindo uma execução segura e confiável.
• Aplicação no mundo real: Ilustra casos práticos de uso, especialmente para profissionais de TI e provedores de serviços gerenciados (MSPs), para simplificar as tarefas de gerenciamento de computadores.

O gerenciamento eficiente da infraestrutura de TI é fundamental para o bom funcionamento das empresas modernas. Entre várias tarefas, renomear computadores, especialmente em um ambiente de domínio, pode ser crucial para manter a organização do sistema, aderir às convenções de nomenclatura e garantir protocolos de segurança. Os scripts do PowerShell surgiram como ferramentas poderosas para automatizar essas tarefas, oferecendo precisão, velocidade e escalabilidade.

Histórico

O script do PowerShell que estamos explorando foi projetado para automatizar o processo de renomeação de computadores. Esse recurso é particularmente valioso para profissionais de TI e provedores de serviços gerenciados (MSPs) que gerenciam grandes redes com várias máquinas. Ele atende à necessidade de uma abordagem consistente e livre de erros para renomear, o que é crucial em ambientes em que os nomes dos computadores geralmente estão alinhados com funções, departamentos ou políticas de uso específicos.

O roteiro:

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

 

Detalhamento

Esse script funciona automatizando o processo de renomeação de computadores Windows, sejam eles associados ou não ao domínio. Aqui está uma explicação passo a passo:

• Declaração de parâmetros: O script começa declarando parâmetros como NewName, DomainUser, DomainPassword e Reboot. Essas entradas determinam o novo nome do computador, as credenciais de domínio e a necessidade de reinicializar a máquina após a renomeação.
• Verificações iniciais e manuseio de credenciais: Ele verifica as variáveis de ambiente e converte senhas de texto simples em cadeias seguras. Para operações de domínio, ele transforma as credenciais de usuário em um objeto de credencial do PowerShell.
• Funções: Várias funções são definidas para verificar se o script está sendo executado com privilégios elevados, se o computador faz parte de um domínio, se está sendo executado como um usuário do sistema e se o usuário é um administrador de domínio.
• Validação: O script valida que um novo nome foi fornecido e que ele é diferente do nome atual. Ele também verifica os privilégios administrativos e a conectividade de domínio, se aplicável.
• Execução: Se todas as verificações forem aprovadas, o cmdlet Rename-Computer será chamado com os parâmetros apropriados. Esse cmdlet é o comando principal que executa o processo de renomeação.
• Manuseio de reinicialização: Se a opção -Reboot for usada, o script programará uma reinicialização do sistema em 5 minutos para aplicar as alterações.

Casos de uso em potencial

Imagine um MSP gerenciando uma rede para uma grande organização que está reestruturando seus departamentos. O MSP usa esse script para renomear com eficiência os computadores em toda a rede para refletir a nova estrutura departamental, garantindo a consistência e reduzindo o esforço manual.

Comparações

Os métodos tradicionais de renomeação de computadores geralmente envolvem intervenção manual, seja por meio das propriedades do sistema ou das ferramentas do controlador de domínio. Esse script oferece uma abordagem mais simplificada e resistente a erros, particularmente útil ao lidar com várias máquinas.

Implicações

Embora esse script simplifique uma tarefa de rotina, o uso inadequado pode levar a conflitos de nomes, problemas de rede ou vulnerabilidades de segurança. É fundamental planejar e revisar as estratégias de renomeação para garantir que estejam alinhadas às políticas organizacionais e às normas de infraestrutura de TI.

Recomendações

• Teste minuciosamente: Execute o script em um ambiente de teste antes de implementá-lo na produção.
• Credenciais seguras: Manuseie e armazene as credenciais com segurança, de preferência usando métodos criptografados.
• Alterações no documento: Mantenha um registro das alterações para fins de solução de problemas e auditoria.

Considerações finais

No âmbito do gerenciamento de TI, ferramentas como o NinjaOne oferecem soluções abrangentes para gerenciar e automatizar as tarefas de TI. A integração desses scripts a uma estrutura de gerenciamento mais ampla, como o NinjaOne, pode aumentar a eficiência, reduzir erros e proporcionar maior controle sobre os ambientes de TI. Ao aproveitar o poder da automação e do gerenciamento central, os profissionais de TI podem se concentrar em iniciativas estratégicas em vez de tarefas rotineiras.