Continue a ler se quer saber como fazer a recolha de dados básicos para Migrações de Windows e assim garantir o sucesso na migração dos seus servidores para a Jotelulu.
Ter informação detalhada e fidedigna da máquina, dos programas e dos serviços é uma garantia de que a migração que se vai realizar decorrerá sem sobressaltos e que teremos uma máquina operacional desde o primeiro momento no nosso novo ambiente. Por isso, devemos definir uma estratégia de migração que inclua a captação da informação pertinente para a migração.
A primeira coisa a definir é a informação que se pretende recolher do sistema. Neste caso, para a migração, considerou-se que a informação mais importante deve ser a seguinte:
- Nome do equipamento.
- Endereço IP e máscara.
- Número de cores.
- Tamanho da memória RAM.
- Número e tamanho dos discos.
Tendo clara a informação que se pretende recolher, deve-se escolher a melhor ferramenta para listá-la no sistema. Neste caso, tratando-se de um servidor Microsoft Windows, a melhor opção é sem dúvida o uso do PowerShell, uma vez que é um sistema nativo e não dependeremos de complementos ou instaláveis, como poderia ser o caso se quiséssemos utilizar Perl ou Python.
Como fazer a recolha de dados básicos para Migrações de Windows
Pré-requisitos ou pré-configuração
Para completar com sucesso este tutorial sobre a recolha de dados básicos para Migrações de Windows, precisará de:
- Estar registado na Plataforma Jotelulu e ter acedido à mesma com o seu nome e palavra-passe através do processo de login.
- Ter uma subscrição de Servidores.
Como fazer a recolha de dados básicos para Migrações de Windows
A seguir, apresentamos o script que propomos para a obtenção da informação desejada. Contudo, como dizemos sempre, não há uma única forma de obter esta informação; de facto, só para obter a informação da CPU no PowerShell podemos usar pelo menos quatro formas diferentes.
O script proposto é:
$Data = Get-Date -Format “yyyy-MM-dd”
$Hora = Get-Date -Format “HH:mm:ss”
$ServerName = $env:COMPUTERNAME
$NetworkInfo = Get-NetIPAddress -AddressFamily IPv4 | Select-Object IPAddress, PrefixLength
$CPUCores = (Get-ComputerInfo).CsNumberOfLogicalProcessors
$RAM = [math]::Round((Get-CimInstance Win32_ComputerSystem).TotalPhysicalMemory / 1GB)
$DiskInfo = Get-Disk | Select-Object Number, @{Name=”Size (GB)”; Expression={ [math]::Round($_.Size / 1GB, 2) }}
Write-Host “########################################################” Write-Host “#### Breve Recolha de Dados do Servidor ####”
Write-Host “########################################################” Write-Host “Informação extraída no dia $Data às $Hora horas”
Write-Host “Nome do Equipamento: $ServerName”
Write-Host “A seguir são listados os Endereços IP e a Máscara de Rede:”
$NetworkInfo | Format-Table -AutoSize
Write-Host “Número de Cores: $CPUCores”
Write-Host “Volume de Memória RAM: $RAM”
Write-Host “Número e Volume de Discos é o seguinte:”
$DiskInfo | Format-Table -AutoSize
Para executá-lo, o recomendável é criar um ficheiro com extensão “.ps1” e copiar o conteúdo do script proposto. É importante estar atento ao fazer o copy/paste, pois é possível que algum carácter fique truncado ou alterado, o que pode causar problemas de execução. A recomendação é verificar bem este ponto para evitar problemas em tempo de execução que podem gerar complicações desnecessária, e sim, infelizmente digo-o por experiência própria.
A seguir, vamos ver uma breve explicação de cada uma das partes.
A primeira coisa a compreender é o uso de variáveis. No início do script, podemos ver que há uma série de linhas que começam com um símbolo de dólar ($) seguido de uma palavra, um sinal de igual (=) e uma série de palavras à frente.
A cadeia inicial antes do igual, como por exemplo “$Data”, é uma variável utilizada para armazenar o resultado do que está depois do igual (=), que será um comando ou conjunto de comandos.
Isto permite trabalhar posteriormente com a saída de alguma maneira, para que as execuções dos comandos sejam apresentadas de forma ordenada.
Sabendo isto, vamos passar a explicar cada uma das linhas uma por uma.
O primeiro comando extrai a data de execução do script, o que pode ser útil para manter um histórico e saber qual é a última versão:
$Data = Get-Date -Format “yyyy-MM-dd”
Onde:
- $Data: É o nome da variável onde armazenamos temporariamente a execução do comando.
- Get-Date: Usa-se para extrair a data e hora do sistema no momento da execução.
- Format “yyyy-MM-dd”: Usa-se para forçar que a saída da data mostre apenas a data no formato Ano (quatro dígitos) + Mês (dois dígitos) + Dia (dois dígitos).
De seguida, executamos um comando semelhante ao anterior em que filtramos apenas a hora:
$Hora = Get-Date -Format “HH:mm:ss”
Onde:
- $Hora: É o nome da variável onde armazenaremos temporariamente a execução do comando.
- Get-Date: É usado para obter a data e hora do sistema no momento da execução.
- -Format “HH:mm:ss”: É usado para forçar a saída da data a exibir apenas a hora num formato específico (dois dígitos) + minutos (dois dígitos) + segundos (dois dígitos).
A seguir, recuperamos o nome da máquina:
$ServerName = $env:COMPUTERNAME
Onde:
- $ServerName: É o nome da variável onde armazenaremos temporariamente a execução do comando.
- $env:COMPUTERNAME: Lista as variáveis de ambiente e recupera o nome da máquina.
Outro ponto importante é a informação sobre as interfaces de rede. É essencial conhecer os endereços IP da máquina, bem como o número de interfaces, os endereços IP e as máscaras de rede associadas. Podemos obter esses dados com o seguinte comando:
$NetworkInfo = Get-NetIPAddress -AddressFamily IPv4 | Select-Object IPAddress, PrefixLength
Onde:
- $NetworkInfo: É o nome da variável onde armazenaremos temporariamente a execução do comando.
- Get-NetIPAddress: É usado para recuperar informações dos dispositivos de rede.
- -AddressFamily IPv4: Filtra e exibe apenas informações dos dispositivos INET IPv4.
- |: Encaminha a saída do comando para o próximo comando, criando uma tubulação (pipeline).
- Select-Object IPAddress, PrefixLength: Filtra a informação, selecionando apenas o endereço IP e a máscara de rede.
Para entender o tamanho da máquina antes da migração e saber o número de cores (núcleos) do processador, pode-se usar o seguinte comando:
$CPUCores = (Get-ComputerInfo).CsNumberOfLogicalProcessors
Onde:
- $CPUCores: É o nome da variável onde armazenaremos temporariamente a execução do comando.
- (Get-ComputerInfo).CsNumberOfLogicalProcessors: Usa-se para recuperar a informação do equipamento e filtrar apenas o número de processadores lógicos.
Outro valor importante para entender o tamanho da máquina antes da migração é a memória física (RAM), que pode ser obtida com o seguinte comando:
$RAM = [math]::Round((Get-CimInstance Win32_ComputerSystem).TotalPhysicalMemory / 1GB)
NOTA: Este é, de longe, o comando mais complexo deste script, pois faz uso de funções matemáticas para arredondamento e outros cálculos. No entanto, sua leitura é mais simples do que sua escrita, e uma breve explicação ajuda a compreender seu funcionamento.
Onde:
- $RAM: É o nome da variável onde armazenaremos temporariamente a execução do comando.
- [math]::Round(): Aplica a função matemática de arredondamento ao resultado do comando contido dentro dos parênteses ().
- (Get-CimInstance Win32_ComputerSystem).TotalPhysicalMemory / 1GB: Usa o Common Information Model (CIM), um serviço de administração do Windows (WMI), para consultar informações de hardware e obter a memória física (RAM). O valor é dividido por 1GB para que o resultado seja apresentado em gigabytes, facilitando a leitura.
Por fim, é necessário coletar informações sobre os discos rígidos disponíveis no sistema. Para isso, utilizamos o seguinte comando em one-liner:
$DiskInfo = Get-Disk | Select-Object Number, @{Name=”Size (GB)”; Expression={ [math]::Round($_.Size / 1GB, 2) }}
Onde:
- $DiskInfo: É o nome da variável onde armazenaremos temporariamente a execução do comando.
- Get-Disk: Obtém informações sobre os discos do sistema.
- |: Encaminha a saída do comando para o próximo comando, a que se chama pipeline.
- Select-Object: Permite selecionar atributos específicos para exibição.
- Number: Mostra os identificadores dos discos.
- @{Name=”Size (GB)”; Expression={ [math]::Round($_.Size / 1GB, 2) }}: Calcula e exibe o tamanho dos discos em gigabytes, arredondado para duas casas decimais.
Agora que terminámos a extração dos dados, passamos para a representação dessas informações.
Nesta parte, há alguns pontos importantes a considerar. O comando Write-Host é utilizado para exibir mensagens no ecrã.
Por exemplo, ao executar: Write-Host “Olá”,será exibido “Olá” no ecrã. Este comando equivale ao echo no CMD ou Bash no GNU/Linux.
Da mesma forma, podemos exibir diretamente o valor de variáveis:
Write-Host “Número de Cores: $CPUCores”
Aqui está a tradução para português de Portugal sem omitir ou alterar o texto:
Onde:
- É feita uma execução de um desses “ecos” que mostram no ecrã uma mensagem e depois fazem também uma chamada a uma variável. Nesses casos, o que será mostrado é o conteúdo da variável que foi guardado anteriormente.
- Vejamos o exemplo de “CPUCores”. Neste ambiente, se executarmos o comando “(Get-ComputerInfo).CsNumberOfLogicalProcessors”, o que acontecerá é que será mostrado um “2”, uma vez que esse é o número de cores da máquina que estamos a utilizar neste caso. O que acontece é que no script redirecionámos esse valor para uma variável “$CPUCores” através da seguinte linha: “$CPUCores = (Get-ComputerInfo).CsNumberOfLogicalProcessors”. Isto fará com que, inicialmente, o valor não seja mostrado, mas sim quando for feita a chamada a essa variável, que, como o leitor terá suposto, será chamada da seguinte forma: Write-Host “Número de Cores: $CPUCores”, pelo que agora, sim, será apresentada no ecrã a mensagem “Número de Cores: 2”.
Por último, temos outro exemplo, o da informação sobre a configuração de rede:
$NetworkInfo | Format-Table -AutoSize
Onde:
- $NetworkInfo: É a varoável que contém as informações de rede, que são consultadas neste momento.
- |: Usa-se para encaminhar a saída do comando para o próximo comando, denominado por pipeline.
- Format-Table -AutoSize: este comando formata a saída em forma de tabela, ajustando automaticamente os tamanhos das colunas.
Com isso, fizemos um resumo geral do script, esperando que tenha sido esclarecedor, pelo menos em parte.
Conclusão
Tal como vimos neste tutorial, saber como fazer a recolha de dados básicos para Migrações de Windows é relativamente simples com o script proposto, pois está perfeitamente estruturado para ser copiado diretamente para a consola de PowerShell. No entanto, recomendamos sempre executá-lo a partir de um ficheiro de script criado para este propósito.
Além disso, é possível realizar diferentes consultas sobre a configuração básica dos dispositivos em sistemas Windows com pequenas variações do que propusemos.
Esperamos que lhe seja útil.
Obrigado por nos ler!
