PowerShell parte 1: a linguagem de scripting moderna

Apresentando o PowerShell - Introdução

Bem-vindos à primeira parte do curso de PowerShell! Meu nome é Guilherme, e ministrarei o treinamento a partir de agora.

Somos administradores de sistemas do banco ByteBank! E estamos com uma cultura de abandonar aqueles antigos .bat e scripts do prompt de comando, para adotarmos cada vez mais o uso do PowerShell!

O PowerShell

Essa linguagem de script tem cada vez mais importância em nosso cenário, pois muitos produtos de servidor, ou produtos para desktop que exigem uma administração e uma configuração, muitos deles, não possuem nem uma interface gráfica que nos permita setar parâmetros. Somente por meio de scripts. E estes produtos estão vindo com suporte ao PowerShell.

Essa é uma tendência muito clara dos produtos da Microsoft. Não somente deles, como também da configuração de ambientes na nuvem como o Azure!

Nesse curso, aprenderemos quais são os conceitos fundamentais do PowerShell.

Na primeira parte, aprenderemos a criar variáveis, veremos como funciona o Pipe Operator "|" , o host do PowerShell, um contexto de execução, profiles, quais são eles e quantos temos disponíveis.

Aprenderemos também o que é uma política de execução dentro do PowerShell. No final, aprenderemos a fazer relatórios, arquivos csv, JSON, para ter uma saída muito mais rica do que somente um arquivo de texto, uma saída de String dos nossos comandos.

Criaremos um relatório gerado em uma página HTML, que poderá ser mostrado para o nosso chefe, e também ser integrado com os nossos colegas de trabalho ou outros desenvolvedores. Esse relatório será criado em JSON e csv.

É fundamental para nós, administradores de sistemas e desenvolvedores, termos esse conhecimento, pois com o PowerShell nos tornaremos muito mais produtivos com essa linguagem de script.

Veremos que no PowerShell não será necessário ter o Google, ou ter a documentação, sempre por perto. Aprenderemos a nos virar sem o acesso à internet, e tirar nossas dúvidas utilizando os recursos implementados nele.

Essa primeira parte do curso é muito importante, pois é a base para que venhamos a avançar ainda mais na segunda parte. Veremos conceitos mais avançados do PowerShell, veremos o que são os jobs, e muito mais.

Vamos começar?

Apresentando o PowerShell - Conhecendo o problema do cliente

Como sabemos, somos administradores de sistemas no ByteBank, e estamos enfrentando o nosso primeiro problema.

Alguns usuários estão reclamando pois estão tendo problemas de performance em suas aplicações. Entretanto, não são todos os usuários. Atendentes, o pessoal do back office, ou até mesmo o setor de investimentos, são usuários que não estão tendo problemas com a performance.

Os usuários afetados são os analistas de dados e, com isso, já sabemos onde podemos olhar a causa desse problema.

Os servidores responsáveis por hospedar as aplicações utilizadas pelos analistas são o SRV01, o SRV02, o SRV03, e assim por diante até o SRV10. São dez servidores que estão redundantes no domínio do ByteBank.

Vamos dar uma olhada em um desses servidores, para ver se encontramos algum problema. Em nossa máquina local, utilizaremos um atalho do Windows para exibir o Executar: "Win + R". Digitaremos o comando MSTSC para abrir a Conexão Remota do Windows.

Caso você não queira utilizar o atalho do sistema, podemos clicar no "Menu Iniciar" e digitar a palavra "Remote".

Sabemos que o SRV01 hospeda uma aplicação dos analistas de dados. Clicamos em "Connect" para nos conectarmos a esse servidor.

Estamos logando com o usuário Administrator do domínio BYTEBANK. Digitamos a senha para ter o acesso a esse servidor.

Após ter acessado o servidor SRV01, vamos dar uma olhada no gerenciador de tarefas para verificar se algum processo está utilizando muitos recursos.

Como podemos ver, temos o ByteBank.inteface.Service utilizando mais de 90% da CPU, e é ele que está causando essa degradação no servidor. Ao clicar com o botão direito nesse processo, podemos ver mais detalhes sobre ele. A partir dos detalhes desse processo, podemos descobrir se há algum serviço que o iniciou, por meio da opção "Go to services". O serviço que faz o uso desse processo é o ByteBank Interface Service.

O ByteBank Interface Service é um serviço interno do nosso banco, que foi desenvolvido aqui mesmo. Sabemos que é possível reiniciar esse serviço sem problemas, pois estamos em uma rede que possui redundância nos outros servidores, e também sabemos que os desenvolvedores mantiveram a integridade dos dados de aplicações que dependiam desse serviço quando um servidor tem esse serviço desativado.

Então, iremos reiniciá-lo com segurança, e veremos se a condição que torna o processo com uso de CPU de 100%, é sanada. Lembrando que esse método não é a solução! Enquanto não levarmos esse problema para os desenvolvedores para discutir em uma reunião o que precisa ser feito, precisamos agir! Nossos analistas precisam desses servidores!

Vamos acessar a aba de "Services", e clicar com o botão direito do mouse em "ByteBank Interface Service", onde selecionaremos a opção "Stop". O processo ByteBank.inteface.Service parou com sucesso. Podemos ter a certeza disso, acessando a aba "Processes".

Voltemos em "Services", e daremos um "Start" nesse serviço. Como podemos ver em "Processes", o processo voltou ao seu funcionamento normal, ou seja, ele não está usando toda a capacidade da CPU.

Será que esse problema também acontece nos outros servidores? Vamos conferir!

Podemos minimizar a tela de conexão remota para o servidor SRV01, utilizaremos o atalho "Win + R", digitaremos o comando MSTSC, e por último conectaremos ao servidor SRV02.

Legal! Depois de ter o acesso ao servidor SRV02, abriremos o "Gerenciador de Tarefas" ou o "Task Manager".

Podemos perceber um cenário semelhante. O serviço que utiliza esse mesmo processo, é o mesmo do SRV01. Vamos repetir o passo de dar um "Stop" nesse serviço, e depois reiniciá-lo com "Start".

Fizemos no SRV01, no SRV02, e agora só falta mais oito, não é mesmo?

Bom, nós podemos abrir várias conexões remotas para esses servidores ao mesmo tempo, realizar o mesmo processo em todos os "Gerenciadores de Tarefas", procurar pelo serviço que está afetando o desempenho, pará-lo e iniciá-lo sem problema nenhum. Mas pessoal, nós como funcionários de TI, nós que trabalhamos com computadores, somos administradores de sistemas… bem, esse não parece ser a maneira mais correta de se resolver esse problema.

Nós poderíamos escrever um script que automaticamente irá reiniciando esses serviços em todos os servidores. A seguir, aprenderemos a fazer esse script.

Apresentando o PowerShell - Tentando solucionar com o antigo CMD

Como profissionais de TI, não vamos usar interface gráfica para fazer uma atividade repetitiva como essa, então vamos começar a escrever o nosso script da forma convencional!

Primeiro, nos conectaremos ao SRV01 somente para ver como o nosso script se comporta. Depois, em nossa máquina local, abriremos o Bloco de Notas para começarmos a escrever.

Para que não fique mostrando várias linhas de comando enquanto executamos esse script, na primeira linhas digitaremos assim:

@ECHO OFF

Para fazer uma query com serviço, usaremos o comando sc e indicaremos em qual servidor será executado esse script (no caso, usaremos o SRV01). Este será o nosso script base:

@ECHO OFF
echo Buscando servico "ByteBank Interface Service" no servidor SRV01
sc \\SRV01 query "ByteBank Interface Service" | find /i "state" | find /i "running"

IF %ERRORLEVEL% NEQ 0 (
    echo Ops, servico nao sendo executado no servidor!
) ELSE (
    echo Parando servico...
    sc \\SRV01 stop "ByteBank Interface Service" > NUL
    echo Iniciando servico...
    sc \\SRV01 start "ByteBank Interface Service" > NUL
    echo Servico Reiniciado com sucesso!
)

A ideia é fazer de forma automática esse procedimento de verificar se o serviço do ByteBank está rodando. Caso ele esteja rodando, ele vai parar e depois iniciar.

Primeiro, utilizamos o comando @ECHO OFF para que não fique mostrando várias linhas de comando durante a execução desse script. Depois utilizamos o comando sc que serve para fazer buscas de serviços e executa mudanças no estado desses serviços. Ele recebe parâmetros, e o primeiro deles é indicado com \\ e o nome da máquina, depois ele executa uma query pelo ByteBank.

O comando sc \\SRV01 query "ByteBank Interface Service" nos retorna um texto totalmente desestruturado que indica o estado do serviço "ByteBank Interface Service". E então precisamos saber se o estado dele é running, ou seja, se ele está rodando! Por isso, fizemos uma busca pelo "state" no resultado do comando sc. O comando /i deixa explícito que é Case Insensitive, então nós não vamos nos preocupar com forma em que o resultado virá.

Depois de ter retornado a linha que possui a propriedade "state", verificaremos se a mesma possui o conteúdo running, ou seja, se o estado do processo está executando. Caso não encontremos o texto "state" ou "running", o comando find altera o valor da variável de erro ERRORLEVEL. Se essa variável for diferente de (não igual - not equals) 0 (zero), será mostrada uma mensagem dizendo que o serviço não está sendo executado, pois ele encontrou um erro no comando find. Se não, quer dizer que ele está executando, e então iremos parar e iniciar com o comando sc, o comando que busca, que para, e também aquele que reinicia o serviço*.

Salvaremos esse script como "reiniciaServicoSrv01.bat" com a extensão .bat, e depois acessaremos o prompt de comando para executar esse script.

> c:\[nome_da_pasta]\reiniciaServicoSrv01.bat

Ao mesmo tempo, a conexão remota para o servidor SRV01 está aberta para que nós possamos acompanhar o estado do serviço "ByteBank Interface Service". Vamos dar um "Enter" no prompt.

C:\Users\administrator>c:\Scripts\reiniciaServicoSrv01.bat
Buscando servico "ByteBank Interface Service" no servidor SRV01
        STATE              : 4   RUNNING
Parando servico...

Legal, podemos acompanhar na conexão remota esse processo.

C:\Users\administrator>c:\Scripts\reiniciaServicoSrv01.bat
Buscando servico "ByteBank Interface Service" no servidor SRV01
        STATE              : 4   RUNNING
Parando servico...
Iniciando servico...
Servico Reiniciado com sucesso

Legal! Este script faz o que precisamos de uma ótima maneira. Revisaremos o script.

Bom, verificamos o estado do serviço "ByteBank Interface Service" no servidor SRV01 através do comando sc. Mas seria muito bom se pudéssemos armazenar a primeira parte desse comando em uma variável, um objeto, e assim verificar uma propriedade de estado, e se essa propriedade de estado está rodando... Só que essa é uma linguagem de script, é o cmd do Windows, e por isso não podemos lidar com objetos.

Então nós temos que lidar com texto! Se queremos saber o retorno de um erro, no comando anterior era necessário saber qual é o %ERRORLEVEL retornado pelo comando find. Precisamos saber que o find muda o valor do "ERRORLEVEL" quando ele não encontra o texto. Assim como precisamos saber que o sc terá um texto exato chamado "state" e o valor retornado por ele que é o "running".

Além de ter esse conhecimento sobre o comando sc, precisamos saber também que, quando utilizamos o stop ou start, ele não apenas retorna serviços como também muda estado de serviços. De certa forma, isso parece pouco intuitivo, não é mesmo? Começando pela convenção de nome sc. Não é todo mundo que sabe o que é sc. Esse comando só é intuitivo para quem tem um pleno conhecimento desses comandos (que na verdade, são bem antigos). Além disso, é necessário saber qual é o formato que sc retorna, para que depois usemos o find. Mesmo assim, colocamos o /i porque não temos a certeza de que a string "state" virá em maiúscula ou minúscula.

Talvez esse processo pudesse ser um pouco melhor! Vamos fazer diferente? Será que o resultado de um comando não pode ser um objeto? Será que não podemos verificar uma propriedade de estado desse objeto como já estamos acostumados com linguagens de programação? Será que também não podemos, em vez de verificar variáveis de erro, e adivinhar o significado de caracteres soltos, ter uma linguagem mais amigável e intuitiva? Vamos fazer isso com o PowerShell?

Sobre o curso PowerShell parte 1: a linguagem de scripting moderna

O curso PowerShell parte 1: a linguagem de scripting moderna possui 186 minutos de vídeos, em um total de 46 atividades. Gostou? Conheça nossos outros cursos de Windows em DevOps, ou leia nossos artigos de DevOps.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Apresentando o PowerShell
• Usando comandos legados e aprendendo sem o Google
• Políticas de Execução e profiles
• Avançando na sintaxe do PowerShell
• Nosso script PS1