Como executar um script PowerShell

O PowerShell é uma linguagem de script e shell de linha de comando projetado para automação de tarefas e gerenciamento de configuração, usado principalmente por administradores de sistema e usuários avançados. Construído sobre a estrutura .NET (.Net Core para o PowerShell 7), ele suporta Windows, Linux e macOS. Ele permite a automação de tarefas administrativas como gerenciar contas de usuários, configurar redes e realizar backups, reduzindo assim o erro humano.

Embora o PowerShell simplifique a administração, pode apresentar desafios, especialmente para iniciantes. Problemas comuns incluem erros de sintaxe, caminhos configurados incorretamente, problemas de dependência e mensagens de erro confusas. Além disso, para aumentar a segurança, a execução de scripts é restrita por padrão, exigindo que os usuários ajustem as políticas de execução para rodar scripts. Para maximizar o potencial do PowerShell mantendo a segurança, os usuários devem combinar o manuseio cuidadoso dos scripts com habilidades de resolução de problemas.

Por que usar scripts PowerShell?

Scripts PowerShell são uma ferramenta vital para administradores de sistemas e desenvolvedores em ambientes Windows e multiplataforma. Automatizar processos como gerenciamento de contas, monitoramento de rede e implantação de software economiza tempo considerável, liberando profissionais de TI para se concentrarem em iniciativas estratégicas, otimização de fluxo de trabalho e resolução de problemas, impulsionando maior eficiência e inovação. Eles podem até agendar scripts para execução automática. O PowerShell Remoting amplifica o valor do PowerShell ao possibilitar o gerenciamento remoto seguro de múltiplos sistemas a partir de uma interface central, reduzindo a necessidade de acesso físico e melhorando os tempos de resposta a incidentes.

O uso de scripts PowerShell também garante a execução consistente e precisa de operações complexas. Eliminar o erro humano é essencial para manter configurações uniformes, conforme necessário para conformidade e segurança. Essa confiabilidade é inestimável em ambientes de grande escala, onde até pequenas inconsistências podem levar a vulnerabilidades ou falhas operacionais.

Entendendo as Políticas de Execução do PowerShell

O PowerShell utiliza execution policies para controlar se os scripts do PowerShell podem ser executados em um sistema e, em caso afirmativo, sob quais condições.

Configurações de Política de Execução

As políticas de execução podem ter as seguintes configurações:

• Restrito: Nenhum script pode ser executado; apenas comandos individuais podem ser executados no prompt do PowerShell. Tentar executar um script leva à mensagem de erro: “A execução de scripts está desativada neste sistema.” Esta é a configuração padrão para a maioria dos sistemas.
• AllSigned: Apenas scripts assinados por um editor confiável podem ser executados. Esta configuração oferece um alto grau de segurança, pois garante que apenas scripts verificados sejam executados.
• RemoteSigned: Scripts criados localmente podem ser executados sem uma assinatura, mas scripts baixados da internet precisam ser assinados por um publicador confiável. Essa política é comumente recomendada para uso rotineiro.
• Sem restrições: Todos os scripts podem ser executados, independentemente de sua origem ou se estão assinados. No entanto, os usuários receberão um aviso quando executarem scripts baixados para alertá-los sobre os riscos.

Como alterar uma política de execução usando Set-ExecutionPolicy

Para modificar uma política de execução, use o cmdlet Set-ExecutionPolicy. O parâmetro -Scope define o escopo: CurrentUser aplica-se apenas ao usuário atualmente logado, enquanto LocalMachine aplica-se a todos os usuários do sistema (usar este valor requer direitos de administrador).

Aqui está um exemplo:

      Set-ExecutionPolicy RemoteSigned -Scope CurrentUser
      

Confirme a alteração digitando Y (Sim) quando solicitado.

Verificando a Política de Execução Usando Get-ExecutionPolicy

Você pode verificar a política de execução atual com o seguinte comando:

      Get-ExecutionPolicy -List
      

Aqui está um exemplo de saída:

Guia Passo a Passo para Executar Scripts do PowerShell

Para executar um script do PowerShell a partir do PowerShell, siga estes passos:

Passo 1: Inicie o PowerShell

Antes de executar um script, você precisa abrir o PowerShell. Aqui estão duas opções:

• Clique no menu Iniciar, digite PowerShell e selecione Windows PowerShell.

• Inicie o prompt de comando digitando cmd no menu Iniciar. Digite powershell para abrir uma sessão do PowerShell.

Passo 2: Navegue até o local do script

Em seguida, navegue até o diretório onde o arquivo .ps1 está armazenado executando o comando cd:

      cd C:\Users\AbbeyCrawford\Scripts
      

Passo 3: Execute o Script

O comando para executar um script PowerShell depende se você está no diretório onde seu script está localizado:

• Se você está no diretório onde seu script está localizado, aqui está como executar um script no PowerShell:

      .\HelloWorld.ps1
      

• Se você não está no diretório do script, para executar um script PowerShell, você deve fornecer o caminho completo:

      C:\Users\JohnDoe\Scripts\HelloWorld.ps1
      

• Se o script estiver em uma subpasta do diretório atual, use o prefixo .\ para fornecer o caminho relativo:

      .\SubFolder\HelloWorld.ps1
      

• Um ponto (.) antes do caminho indica que você deseja executar o script na sessão atual para permitir que suas variáveis ou funções permaneçam disponíveis após a execução. (A técnica de dot sourcing é explicada com mais detalhes posteriormente neste documento.) Observe o espaço entre os dois pontos.

      . .\HellowWorld.ps1
      

      . C:\Scripts\MyScripts\HelloWorld.ps1
      

Executando scripts com parâmetros

Muitos scripts do PowerShell aceitam parâmetros para torná-los mais flexíveis. Você pode passar argumentos ao executar o script.

Por exemplo, suponha que você tenha o seguinte script que aceita dois parâmetros, Name e Age:

      param(

    [string]$Name,

    [int]$Age

)

Write-Host "Hello, $Name! You are $Age years old."

When running the script, you can pass arguments to it as follows:

.\Get-UserInfo.ps1 -Name "John" -Age 30
      

Como executar um script do PowerShell a partir do CMD

Para executar um script PowerShell a partir do prompt de comando, siga os passos a seguir:

1. Abra o prompt de comando digitando cmd na barra de pesquisa e pressionando Enter.
2. Utilize o seguinte comando para executar o seu script PowerShell. A opção -File é necessária; ela especifica o arquivo de script a ser executado.

      powershell -File C:\Scripts\Get-UserInfo.ps1
      

Usando a opção -NoExit Option

Em alguns casos, você pode querer que a janela do PowerShell permaneça aberta após a execução do seu script. Isso pode ser particularmente útil para depuração ou quando o script é projetado para exibir saídas que você deseja ver antes que a janela se feche.

Para manter a janela do PowerShell aberta ao executar scripts a partir do prompt de comando, utilize a opção -NoExit conforme mostrado abaixo:

      powershell -NoExit -File C:\Scripts\Backup.ps1
      

Como executar o PowerShell como Administrador

Muitas tarefas administrativas requerem permissões elevadas para serem executadas com sucesso. Exemplos incluem instalar software, modificar configurações de rede e acessar diretórios do sistema. Tentar realizar essas tarefas sem direitos administrativos pode resultar em erros, que poderiam bloquear tarefas importantes de manutenção ou configuração.

Para executar o PowerShell com privilégios administrativos, clique com o botão direito em Windows PowerShell e escolha Executar como Administrador.

Usando Start-Process para Execução Administrativa

Em algumas situações, você precisa executar outra instância do PowerShell ou um script dentro de uma sessão do PowerShell. O cmdlet Start-Process é uma ferramenta perfeita. Adicionar o parâmetro -Verb RunAs instrui o PowerShell a iniciar uma nova instância com direitos administrativos:

      Start-Process PowerShell -Verb RunAs
      

Para executar um script específico com privilégios elevados, adicione o parâmetro -ArgumentList e use -File para especificar o caminho do script. Abaixo estão dois exemplos:

      Start-Process PowerShell -ArgumentList '-File "C:\Scripts\Update-Software.ps1"' -Verb RunAs
      

      Start-Process powershell -ArgumentList "-NoProfile -ExecutionPolicy Bypass -File “ C:\Scripts\Update-Software.ps1” -Verb RunAs
      

Erros Comuns e Como Corrigi-los

Resolver erros pode parecer assustador inicialmente, mas solucioná-los é um passo significativo, semelhante a ganhar distintivos de ouro, prata e bronze por habilidades de depuração. Abaixo estão alguns dos problemas mais comuns e como resolvê-los eficazmente.

Erro “Running scripts is disabled”

Este erro ocorre porque a política de execução padrão do PowerShell está definida como Restricted, o que impede a execução de quaisquer scripts. Por exemplo, a captura de tela abaixo mostra o erro, “O arquivo C:\Scripts\Get-UserInfo.ps1 não pode ser carregado porque a execução de scripts está desativada neste sistema”:

Para resolver este problema, modifique a política de execução para permitir a execução de scripts. Use Set-ExecutionPolicy para alterar para uma configuração menos restritiva, como RemoteSigned.

Erros de Sintaxe

Erros de sintaxe geralmente ocorrem devido a uma estrutura de comando incorreta, parâmetros ausentes ou erros de digitação. Aqui está um exemplo:

Para corrigir erros de sintaxe, leia atentamente as mensagens de erro exibidas e verifique o número da linha indicado para identificar onde ocorreu o erro. Para prevenir erros, sempre revise seu script em busca de erros comuns e considere usar um editor de código que ofereça recursos de realce de sintaxe ou IntelliSense.

Erros de Permissões

Erros de permissões ocorrem quando o script tenta acessar recursos que exigem privilégios elevados ou quando as permissões de arquivo/pasta são insuficientes. Por exemplo, o erro abaixo indica que o acesso ao caminho C:\Backup\Backup.txt foi negado:

Aqui estão duas maneiras de resolver o problema:

• Clique com o botão direito em PowerShell, selecione Executar como Administrador e execute seu script novamente.
• Verifique as permissões do arquivo ou pasta que o script está acessando e conceda as permissões necessárias usando os cmdlets Get-Acl e Set-Acl.

Executando scripts PowerShell em diferentes ambientes

O processo para executar scripts PowerShell difere dependendo se você está executando-os:

• No PowerShell Integrated Scripting Environment (ISE)
• Através do Explorador de Arquivos
• Usando comandos remotamente como Invoke-Command

Executando scripts no PowerShell ISE

O PowerShell ISE é um ambiente de desenvolvimento amigável projetado para escrever, testar e depurar scripts PowerShell. Ele oferece uma interface com múltiplos painéis com recursos como realce de sintaxe e ferramentas de depuração integradas. Para executar scripts no PowerShell ISE, siga estes passos:

1. Abra o PowerShell ISE. Para localizá-lo, você pode procurar por PowerShell ISE no menu Iniciar, ou digitar powershell_ise na caixa de diálogo Run (Windows + R). Aqui está a interface resultante:

• Utilize o painel de script (janela superior) para escrever ou carregar scripts. Para criar um novo arquivo .ps1, pressione FileèNew. Para salvar o seu script, clique em File > Save As.
• Para executar seu script completo, clique no botão Run Script (triângulo verde) ou pressione F5. Para executar linhas selecionadas, destaque-as e pressione F8.

Executando scripts a partir do Explorador de Arquivos

Outro método conveniente para executar scripts PowerShell é diretamente do Explorador de Arquivos. Essa abordagem é benéfica quando você deseja executar um script sem a necessidade de abrir uma janela de terminal ou para acesso rápido.

1. Navegue até a pasta que contém o seu script PowerShell.
2. Clique com o botão direito do mouse no arquivo de script .ps1. No menu de contexto, selecione Executar com o PowerShell. Isso iniciará o script em uma nova janela do PowerShell e o executará imediatamente.

Executando Scripts Remotamente

O PowerShell também oferece a capacidade de executar scripts em máquinas remotas sem a necessidade de acesso físico. Isso é especialmente útil em ambientes empresariais onde tarefas precisam ser executadas em vários servidores.

Pré-requisito: Ativar Execução Remota

Antes de poder executar um script remotamente, você deve habilitar o PowerShell Remoting no sistema alvo. Execute o seguinte comando:

      Enable-PSRemoting -Force
      

Sintaxe Básica para Invoke-Command

Invoke-Command permite que você execute cmdlets ou scripts em computadores remotos. Por exemplo, para executar UpdateSystem.ps1 em um computador remoto chamado Server01, use o seguinte cmdlet:

      Invoke-Command -ComputerName Server01 -FilePath C:\Scripts\UpdateSystem.ps1
      

Fornecendo um Bloco de Script para Execução

Para executar um bloco de script diretamente, use esta sintaxe:

      Invoke-Command -ComputerName Server01 -ScriptBlock { Get-Process }
      

Executando comandos em vários computadores

Para executar scripts em vários computadores, você pode especificar os nomes dos computadores usando uma variável, conforme mostrado abaixo:

      $computers = "PC1", "PC2", "PC3"

Invoke-Command -ComputerName $computers -ScriptBlock { Your PowerShell Commands }
      

Alternativamente, você pode passar os nomes dos computadores como uma lista separada por vírgulas:

      Invoke-Command -ComputerName Server01, Server02 -ScriptBlock { Restart-Service -Name Spooler }
      

Automatizando scripts do PowerShell com o Agendador de Tarefas

O Agendador de Tarefas do Windows, uma ferramenta integrada ao sistema operacional Windows, permite aos usuários programar tarefas para serem executadas em uma data e hora específicas, em um cronograma definido ou quando acionadas por determinados eventos.

Para saber mais sobre os benefícios de agendar scripts do PowerShell e obter instruções detalhadas, exemplos, melhores práticas e dicas de solução de problemas, consulte este artigo: Como Automatizar Scripts do PowerShell com o Agendador de Tarefas.

Técnicas Avançadas

O PowerShell oferece técnicas avançadas para aprimorar a reutilização de scripts, modularidade e compartilhamento de variáveis e funções entre scripts. Dois conceitos chave são a fonte pontual e os módulos de script.

Dot Sourcing

Normalmente, cada script é executado em uma nova sessão, e quaisquer variáveis ou funções declaradas dentro dele são perdidas quando o script termina. Com a utilização de dot sourcing, um script é executado no escopo atual de forma que quaisquer variáveis, funções ou aliases definidos nesse script estejam disponíveis na sessão que o chamou. Isso é particularmente útil quando você deseja compartilhar funções ou variáveis comuns entre scripts ou dentro da mesma sessão.

A sintaxe é a seguinte:

      . .\ScriptName.ps1
      

O primeiro ponto seguido de um espaço (. ) indica ao PowerShell que você está utilizando a técnica de dot sourcing no script.

A segunda parte (.\ScriptName.ps1) é o caminho relativo para o seu script.

Usando Módulos de Script

Um módulo no PowerShell é um pacote que contém funções do PowerShell, cmdlets, variáveis e mais. Os módulos são projetados para serem importados e utilizados em vários scripts. Comparados ao dot sourcing, os módulos oferecem melhor encapsulamento e versionamento, o que facilita organizar, manter e compartilhar scripts reutilizáveis.

Para criar um módulo de script, basta salvar seu script com uma extensão de arquivo .psm1 em vez de .ps1.

Uma vez que você tenha criado um módulo, você pode disponibilizar suas funções na sua sessão do PowerShell usando o Import-Module da seguinte forma:

      Import-Module C:\Scripts\Modules\Geometry.psm1
      

Melhores práticas para executar scripts PowerShell

As seguintes melhores práticas são essenciais para manter a segurança ao executar scripts PowerShell, bem como para melhorar a usabilidade e precisão dos scripts.

Melhores Práticas de Segurança

Use configurações de política de execução fortes

Use as políticas de execução do PowerShell para permitir apenas scripts de fontes confiáveis e verificadas. Defina a política de execução para um nível apropriado para o seu ambiente. Para a maioria das organizações, RemoteSigned oferece um bom equilíbrio, permitindo a execução de scripts criados localmente enquanto exige que scripts baixados sejam assinados por um editor confiável.

Assine digitalmente seus scripts

O PowerShell verifica a assinatura digital de um script antes de executá-lo. Assinar digitalmente seus scripts com um certificado confiável ajuda a proteger contra adulterações.

Execute Scripts com os Menores Privilégios Necessários

Sempre que possível, execute scripts com o menor privilégio para limitar possíveis danos em caso de vulnerabilidades de segurança ou erros.

Melhores Práticas de Documentação

Scripts bem documentados são mais fáceis de manter, depurar e entender para os usuários atuais e futuros.

Use Comentários

Os comentários são importantes para explicar o propósito do script, parâmetros e lógica. No PowerShell, os comentários são prefixados com o símbolo #.

Para explicações rápidas, use comentários inline:

      $backupDirectory = "D:\Backup"  # Set the backup directory
      

Para fornecer explicações mais detalhadas ou para desativar temporariamente partes do seu código, use comentários de bloco (<# … #>):

      <#
      

Este script realiza um backup de dados críticos.

Verifica o espaço disponível e confirma a integridade do backup.

      #>
      

Verifique a Ajuda

Para garantir que você está usando as funções do PowerShell corretamente, use Get-Help para revisar a sintaxe e o uso do cmdlet. Por exemplo, para obter ajuda sobre Get-Process, execute o seguinte comando:

      Get-Help Get-Process
      

Melhores Práticas de Tratamento de Erros

Um tratamento adequado de erros é essencial para evitar que scripts PowerShell falhem inesperadamente e deixem tarefas incompletas ou sistemas em um estado instável.

Validar Entrada

Para evitar erros inesperados, certifique-se de que seus scripts validem as entradas. Isso é especialmente importante para dados relacionados ao usuário, como nomes ou avatares de usuário.

Implement Try-Catch Blocks

O bloco try-catch é o método principal para tratamento de erros no PowerShell. Isso permite que você capture e lide com exceções de maneira elegante. Aqui está um exemplo:

      try {

       # Attempt to run a command

       Copy-Item -Path $source -Destination $destination -Recurse

   } catch {

       # Handle the error

       Write-Host "An error occurred: $_"

       # Additional error recovery actions can be performed here

   }
      

Use Finally Blocks

Adicione um bloco final quando necessário. Este bloco será executado independentemente de ter ocorrido um erro no bloco try , permitindo que você libere recursos ou execute o código de finalização. Abaixo está um exemplo:

      try {

       # Code that may throw an exception

       Remove-Item -Path $filePath -ErrorAction Stop

   } catch {

       Write-Host "Failed to remove the file: $_"

   } finally {

       Write-Host "Cleanup actions have been performed."

   }
      

Conclusão

O PowerShell é uma ferramenta incrivelmente poderosa para automatizar tarefas de administração de sistemas a fim de garantir precisão e melhorar a eficiência. Ao compreender conceitos fundamentais como políticas de execução, dot sourcing e módulos de script, bem como seguir as melhores práticas de segurança e tratamento de erros, você pode aproveitar ao máximo o PowerShell para escrever scripts robustos, reutilizáveis e seguros que melhoram suas operações do dia a dia.

Incentivamos você a começar a experimentar o PowerShell escrevendo e executando seus próprios scripts. Comece com tarefas simples de automação e mergulhe gradualmente em técnicas avançadas de script. Quanto mais você praticar, mais proficiente se tornará na automação de fluxos de trabalho complexos, gerenciamento de sistemas remotos e manipulação de operações de TI em larga escala.