Processando Dados CSV com Import-Csv e Loop ForEach em PowerShell

Tutoriais
PowerShell

Você já teve que realizar a mesma tarefa várias vezes? Por exemplo, criar vários usuários do Active Directory um de cada vez usando a interface gráfica? Ou então, fazer login em um servidor para excluir logs antigos de algumas pastas selecionadas? Se a sua resposta for sim, saiba que você não está sozinho. É hora de dominar o Import-Csv do PowerShell e o loop foreach.

Não há nada de errado com tarefas manuais; às vezes é necessário. Mas quando se trata de ler e processar arquivos CSV, o cmdlet Import-Csv do PowerShell e o loop ForEach podem ajudar.

O cmdlet Import-Csv do PowerShell é uma excelente maneira de ler dados de uma fonte tabulada, como um arquivo CSV. Você pode usar o loop ForEach para iterar sobre cada linha nos dados CSV.

Neste artigo, você aprenderá como usar essa combinação poderosa para automatizar tarefas em massa, mundanas e repetitivas.

Se você é novo no cmdlet Import-Csv e no loop ForEach, ou se deseja relembrar o que já sabe, você pode visitar estes links para saber mais.

Gerenciando arquivos CSV no PowerShell com Import-Csv (loop foreach)

Voltando ao básico: o loop foreach do PowerShell

Pré-requisitos

Há vários exemplos e demonstrações neste artigo. Para acompanhar, você precisará de algumas coisas primeiro.

  • A script editor such as Visual Studio Code, Atom, or Notepad++. Use whichever one you’re comfortable with.
  • Windows PowerShell 5.1 ou PowerShell Core 6+
  • Acesso ao Exchange Online (opcional se você seguir o exemplo prático relacionado ao Exchange Online).

Colocando Import-Csv e o Loop ForEach em Ação

Nas próximas seções, há vários exemplos de como usar o cmdlet Import-Csv e o loop ForEach que você pode encontrar em cenários do mundo real. Embora esses exemplos de importação CSV foreach do PowerShell sejam específicos para cada finalidade, é crucial entender que o conceito e a técnica empregada são os mesmos.

Lendo e Exibindo Registros de um CSV

Talvez o uso mais básico do Import-Csv e do loop ForEach seja a leitura de registros de um arquivo e a exibição deles no console. A anatomia de um arquivo CSV é semelhante à de um banco de dados. Ele possui cabeçalhos de coluna e cada linha é considerada como um registro.

Por exemplo, abaixo está o conteúdo do arquivo chamado employee.csv, que consiste em três colunas – EmployeeID, Name e Birthday, e quatro registros.

CSV containing employee records

O código abaixo importa o conteúdo do arquivo employee.csv e, em seguida, redireciona os dados importados para o cmdlet ForEach-Object. Em seguida, o ForEach-Object percorrerá cada registro no CSV importado para exibir os valores concatenados no console. Copie o código abaixo e salve-o como list-employee.ps1.

Nota: O tipo de loop ForEach usado neste exemplo abaixo é o cmdlet ForEach-Object. Consulte a seção “O cmdlet ForEach-Object” neste artigo.

Import-Csv .\employee.csv | ForEach-Object {
    Write-Host "$($_.Name), whose Employee ID is $($_.EmployeeID), was born on $($_.Birthday)."
}

Uma vez que o script esteja salvo, execute-o chamando seu nome de arquivo no PowerShell. Quando o script for executado, você deverá ver uma saída semelhante à captura de tela abaixo.

Imported CSV records displayed in the console

Pesquisando e Exibindo Registros de um CSV

No exemplo anterior, você aprendeu como ler e exibir todos os registros de um CSV. Neste exemplo, o mesmo arquivo CSV employee.csv será usado, mas desta vez, você criará uma função do PowerShell para pesquisar um EmployeeID no CSV.

O trecho de código abaixo é uma função do PowerShell chamada Find-Employee que possui apenas um parâmetro. O nome do parâmetro é EmployeeID e ele aceita um valor de ID do funcionário a ser pesquisado no CSV.

Antes que esta função possa ser usada, ela precisa ser importada para a sessão do PowerShell primeiro. Existem duas maneiras de importar a função Find-Employee para a memória:

  1. Copiar e colar o código abaixo no PowerShell.
  2. Salvar o script como Find-Employee.ps1 e importá-lo usando a técnica de fonte pontual.

Nota: O tipo de loop ForEach usado no exemplo abaixo é o ForEach Statement. Consulte a seção “A declaração foreach” neste artigo.

Function Find-Employee {
    param (
        # O parâmetro aceita o ID do funcionário a ser pesquisado.
        [Parameter(Mandatory)]
        $EmployeeID
    )

    # Importe o conteúdo do arquivo employee.csv e armazene-o na variável $employee_list.
    $employee_list = Import-Csv .\employee.csv

    # Percorra todos os registros no CSV
    foreach ($employee in $employee_list) {

        # Verifique se o ID do funcionário do registro atual é igual ao valor do parâmetro EmployeeID.
        if ($employee.EmployeeID -eq $EmployeeID) {

            # Se o EmployeeID for encontrado, exiba o registro no console.
            Write-Host "$($employee.Name), whose Employee ID is $($employee.EmployeeID), was born on $($employee.Birthday)."
        }
    }
}

Depois que o código da função for importado para a sessão do PowerShell, chame-o digitando o nome da função conforme abaixo.

Find-Employee

Ao executar a função sem usar o parâmetro EmployeeID, ela solicitará o valor do EmployeeID a ser pesquisado. Veja o exemplo de saída abaixo.

Function to search a CSV file for a specific record

Ou, a função pode ser executada com o valor do parâmetro EmployeeID especificado durante a execução, como mostrado abaixo.

Find-Employee -EmployeeID 'E-2023'

Obtendo o uso do espaço em disco de vários servidores

Uma tarefa comum entre os administradores de sistemas é monitorar o uso do espaço em disco de vários servidores. Em vez de fazer login em cada servidor para verificar o uso do espaço em disco, você pode criar uma lista CSV contendo nomes de servidores, letras de unidade e limites. Em seguida, usando o PowerShell, importe o arquivo CSV e percorra cada linha para executar uma consulta.

Para criar um script que obtenha o uso do espaço em disco de servidores remotos, primeiro crie a lista CSV com os seguintes cabeçalhos:

  • servername – este é o nome do servidor a ser consultado.
  • disk – esta é a letra da unidade cujo uso de espaço será obtido.
  • threshold – isso define o limite em GB. Se o espaço livre do disco for menor que esse valor, o relatório mostrará um status de aviso.

O exemplo abaixo mostra que existem quatro registros listados. Seu arquivo CSV será diferente dependendo do número de servidores ou discos a serem lidos.

servername,disk,threshold
au-dc01,c,120
au-mail01,c,100
au-mail01,d,6
au-file01,c,120

Assim que o CSV estiver finalizado, salve o arquivo como servers.csv. Isso servirá como a lista de entrada que será importada pelo script do PowerShell.

Para fornecer um exemplo de obtenção do uso do espaço em disco, copie o código abaixo para o seu editor de script e salve-o como diskReport.ps1. O script deve ser salvo no mesmo local do caminho do CSV.

$server_list = Import-Csv -Path .\servers.csv

foreach ($server in $server_list) {
    Get-WmiObject -Class Win32_logicaldisk -ComputerName ($server.servername) | `
        Where-Object { $_.DeviceID -match ($server.disk) } | `
        Select-Object `
    @{n = 'Server Name'; e = { $_.SystemName } }, `
    @{n = 'Disk Letter'; e = { $_.DeviceID } }, `
    @{n = 'Size (GB)'; e = { $_.Size / 1gb -as [int] } }, `
    @{n = 'Free (GB)'; e = { $_.FreeSpace / 1gb -as [int] } }, `
    @{n = 'Threshold (GB)'; e = { $server.Threshold } }, `
    @{n = 'Status'; e = {
            if (($_.FreeSpace / 1gb) -lt ($server.Threshold)) {
                return 'Warning'
            }
            else {
                return 'Normal'
            }
        }
    }
}

O script acima executa as seguintes ações quando é executado.

  • Importa o arquivo csv com o nome servers.csv e o armazena na variável $server_list.
  • Percorre a lista de servidores armazenada na variável $server_list.
  • Em cada iteração do loop foreach, a linha atual é representada pela variável $server.
  • Obtém as informações de disco dos servidores usando o cmdlet Get-WmiObject.
  • Selecione apenas as propriedades relevantes para exibir.
    – Nome do Servidor – Este é o nome do sistema que está sendo consultado.
    – Letra do Disco – A letra atribuída à unidade.
    – Tamanho (GB) – O tamanho do disco em GB
    – Gratuito (GB) – O tamanho do espaço livre em GB
    – Limite (GB) – O limite definido em GB
    – Status – Se o valor Gratuito (GB) for menor que o valor Limite (GB), o status retornado será ‘Aviso’. Caso contrário, o status será ‘Normal’

Após salvar o arquivo de script diskReport.ps1, ele está pronto para ser executado chamando seu nome no PowerShell.

./diskReport.ps1

Uma vez executado, a captura de tela abaixo mostra a saída do script.

Disk space information gathered from multiple servers

A saída também pode ser exportada para CSV. Exportar para CSV é útil quando o relatório precisa ser compartilhado, pois o arquivo CSV exportado pode ser enviado por e-mail ou carregado em um compartilhamento de arquivos ou em um site SharePoint. Não deixe de conferir Exportar-Csv: A maneira do PowerShell de tratar arquivos CSV como cidadãos de primeira classe se você quiser obter mais informações sobre a exportação para CSV.

Criando Múltiplos Usuários do Active Directory

Neste ponto, você já deve ter uma ideia sólida sobre o uso de Import-Csv e ForEach. Este próximo exemplo leva seu aprendizado um pouco mais longe, adicionando os cmdlets New-ADUser e Get-ADUser à mistura.

Vamos supor que você tenha recebido um arquivo CSV chamado “new_employees.csv” contendo a lista dos novos funcionários do departamento de RH. Cada linha no arquivo CSV representa um usuário a ser incorporado e possui as seguintes colunas: FirstName, LastName, Department, State, EmployeeID e Office.

O nome de usuário deve ser derivado da primeira letra do primeiro nome do funcionário concatenada com o sobrenome (por exemplo, bparr para o usuário Bob Parr).

CSV file containing new employees information for on-boarding

Após salvar o arquivo CSV, o script abaixo utiliza o comando Import-Csv para ler o arquivo CSV new_employees.csv. Em seguida, itera por cada linha, passando os valores para os parâmetros apropriados do comando New-ADUser.

Import-Csv .\new_employees.csv | ForEach-Object {
    New-ADUser `
        -Name $($_.FirstName + " " + $_.LastName) `
        -GivenName $_.FirstName `
        -Surname $_.LastName `
        -Department $_.Department `
        -State $_.State `
        -EmployeeID $_.EmployeeID `
        -DisplayName $($_.FirstName + " " + $_.LastName) `
        -Office $_.Office `
        -UserPrincipalName $_.UserPrincipalName `
        -SamAccountName $_.SamAccountName `
        -AccountPassword $(ConvertTo-SecureString $_.Password -AsPlainText -Force) `
        -Enabled $True
}

Após executar o script, os novos usuários devem existir no Active Directory. No entanto, é uma boa prática confirmar se as contas de usuário foram realmente criadas.

Utilizando o mesmo arquivo CSV new_employees.csv como referência, o script abaixo irá importar o CSV e, para cada objeto ADUser, verificar se há correspondência com os da lista.

Import-Csv .\new_employees.csv | ForEach-Object {
	Get-AdUser $_.SamAccountName
}

Adicionando um endereço de e-mail proxy à caixa de correio do Office 365

No gerenciamento de caixas de correio do Office 365, solicitações para adicionar endereços proxy para vários usuários não são incomuns. Normalmente, nesse tipo de solicitação, o administrador recebe uma lista de usuários e o endereço de e-mail a ser adicionado, semelhante ao exemplo de CSV abaixo.

The new_address.csv file contents

Observação: Antes de executar qualquer cmdlet do Exchange Online no PowerShell, você deve fazer login no shell de Gerenciamento do Exchange Online primeiro.

Usando o Import-Csv e o loop ForEach em um script do PowerShell, a lista pode ser processada de uma só vez. O script abaixo mostra como pode ser feito.

O script abaixo importa o conteúdo do arquivo new_address.csv e armazena-o na variável $user_list. Em seguida, usando o método foreach(), o PowerShell percorre toda a lista de usuários e usa os valores username e email em cada registro para adicionar um novo endereço de e-mail a cada caixa de correio.

$user_list = Import-Csv .\new_address.csv

$user_list.foreach(
    {
        Set-Mailbox -Identity $_.username -EmailAddresses @{add="$($_.email)"}
    }
)

Depois de executar o script, não será exibida nenhuma saída no console. Nenhuma saída na tela significa que o novo endereço de e-mail foi adicionado com sucesso. Mas, como você pode ter certeza de que os endereços de e-mail foram adicionados?

Usando o mesmo arquivo CSV new_address.csv como referência, é possível verificar se os novos endereços foram adicionados usando os comandos Import-Csv e ForEach.

O script abaixo importa o conteúdo do arquivo new_address.csv e armazena-o na variável $user_list. Em seguida, usando o método foreach(), o PowerShell percorre toda a lista de usuários para verificar se o novo endereço de e-mail existe na lista de endereços de proxy da caixa de correio. Se encontrado, o status retornará Verdadeiro; caso contrário, o resultado será Falso.

$user_list = Import-Csv .\new_address.csv

$user_list.foreach(
    {
        $emailObj = (Get-Mailbox -Identity $_.username).EmailAddresses
        if ($emailObj -contains $_.email) {
            Write-Host "$($_.username) --> $($_.email) --> TRUE"
        }
        else {
            Write-Host "$($_.username) --> $($_.email) --> FALSE"
        }
    }
)

Quando o script de validação é executado, a saída deve ser semelhante à mostrada na captura de tela abaixo. Você notará na saída abaixo que o status é todo VERDADEIRO, o que significa que os novos endereços de e-mail foram adicionados com sucesso a cada caixa de correio.

Running the new email address verification

Enviando Previsão Diária do Tempo para uma Lista de Emails

Neste exemplo, pressupõe-se que você tenha um arquivo CSV contendo uma lista de endereços de e-mail dos assinantes e sua área ou localização. Esses assinantes estão esperando um e-mail diário contendo a previsão do tempo para o dia específico de sua localização. Dê uma olhada no exemplo de CSV abaixo com o nome de arquivo subscribers.csv.

Weather forecast subscribers list

O CSV abaixo contém apenas dois assinantes. Um em Los Angeles e outro em Manila.

O objetivo é criar um script que execute as seguintes ações:

  • Importar as informações de e-mail e área do arquivo subscribers.csv
  • Para cada assinante:
    – Baixar a imagem da previsão do tempo com base na área do assinante em https://wttr.in/
    – Enviar a imagem da previsão do tempo por e-mail para o endereço de e-mail do assinante.

O script abaixo executa as ações mencionadas acima. Você só precisa modificar as três primeiras variáveis – $senderAddress, $smtpServer e $smtpPort. Em seguida, copie este código e salve-o como Send-WeatherInfo.ps1. Consulte os comentários acima de cada seção do script para saber mais sobre o que o código faz.

# COMECE aqui as configurações do SMTP
$senderAddress = '<SENDER EMAIL ADDRESS HERE'
$smtpServer = '<SMTP RELAY SERVER HERE>'
$smtpPort = 25
# COMECE aqui as configurações do SMTP

# Importe a lista de emails dos assinantes
$subscriber_list = Import-Csv .\subscribers.csv

# Obtenha a previsão do tempo e envie um email
$subscriber_list.foreach(
    {
				
        # Construa a URL para obter informações climáticas com base na área
        $uri = ('<https://wttr.in/>' + $_.Area + '_u1F.png')
        # Obtenha a imagem da previsão do tempo da área. Salve a imagem como <AREA>.png
        $imageFile = (((Resolve-Path .\).Path) + "$($_.Area).png")
        Start-BitsTransfer $uri -Destination $imageFile

        # Crie um objeto de anexo
        $attachment = New-Object System.Net.Mail.Attachment -ArgumentList $imageFile
        $attachment.ContentDisposition.Inline = $true
        $attachment.ContentDisposition.DispositionType = "Inline"
        $attachment.ContentType.MediaType = "image/png"
        $attachment.ContentId = "weatherImage"

        # Componha a mensagem
        $emailMessage = New-Object System.Net.Mail.MailMessage
        $emailMessage.From = $senderAddress
        $emailMessage.To.Add($_.Email)
        $emailMessage.Subject = ('Weather Forecast - ' + $_.Area)
        $emailMessage.IsBodyHtml = $true
        $emailMessage.Body = '<img src="cid:weatherImage">'
        $emailMessage.Attachments.Add($attachment)

        # Envie a mensagem
        Write-Output "Sending Weather Info to $($_.Email)"
				$smtp = New-Object Net.Mail.SmtpClient($smtpServer, $smtpPort)
        $smtp.Send($emailMessage)

        # Descarte os objetos
        $attachment.Dispose()
        $emailMessage.Dispose()
    }
)

Uma vez que o script seja executado, um email será enviado para cada assinante, semelhante ao exemplo de captura de tela de email abaixo.

Weather forecast for Manila sent as an email to the subscriber
Weather forecast for Los Angeles sent as an email to the subscriber

Resumo

Não há limite para as tarefas em que o Import-Csv e o loop ForEach podem ser aplicados. Desde que a tarefa envolva uma lista com colunas delimitadas, você pode aproveitar essa poderosa combinação.

Neste artigo, você aprendeu como um arquivo CSV é semelhante a um banco de dados. Você também aprendeu como usar o Import-Csv para importar dados e como referenciar os valores durante a iteração do loop ForEach.

I hope that with the many examples provided in this article, you now understand more of the Import-Csv and ForEach. And, that you would be able to use the knowledge you gained in this article in your administration and automation tasks.

Leitura adicional

Source:
https://adamtheautomator.com/import-csv-and-the-foreach-loop/