Usando PowerShell com Linux

O que é PowerShell?

O PowerShell é uma solução de plataforma cruzada comumente usada para automatizar o gerenciamento de sistemas de computador, mas também pode ser usada para codificação geral.O PowerShell é composto por um shell de linha de comando, uma linguagem de script e uma estrutura de gerenciamento de configuração.O PowerShell é executado no Windows, Linux e nos sistemas operacionais MacOS.Devido a diferenças fundamentais nos sistemas operacionais, alguns comandos do PowerShell (chamados cmdlets) não fazem sentido.Por exemplo, o PowerShell Get-acl O CMDLET não é aplicável aos sistemas Linux, pois o sistema de arquivos Linux não usa listas de controle de acesso NTFS (ACLs).Para visualizar uma lista dos cmdlets Linux PowerShell disponíveis, execute Get-Command.

Por que Linux PowerShell?

No Linux, a saída de um comando pode ser transferido para outro comando.Por exemplo:

ls | sort -r | more

Esse reverso classifica o conteúdo do diretório atual e pagina a lista (se necessário).Isto é, a saída do fluxo de dados do ls O comando é canalizado para o ordenar comando cuja saída do fluxo de dados é então canalizada para o Mais comando.O análogo do PowerShell é o seguinte:

Get-ChildItem | Sort-Object -Descending | Out-Host -Paging

O que levanta a pergunta: por que você deseja usar o PowerShell sobre a versão nativa?Um dos principais motivos é que os objetos, e não fluxos de dados simples, são canalizados entre os cmdlets do PowerShell.Por exemplo, não há necessidade de analisar o texto para extrair informações de outro fluxo de saída.E como os objetos do PowerShell geralmente têm uma infinidade de propriedades associadas a eles, você pode fazer algumas coisas bastante poderosas com relativa facilidade.Por exemplo, digamos que você gostaria de encontrar o PID do serviço Cron.Uma primeira tentativa pode ser a seguinte:

ps -aux | grep cron

Isso resulta em produção semelhante ao seguinte:

root      1041  0.0  0.1 126384  1584 ?        Ss   22:25   0:00 /usr/sbin/crond -n
root      3519  0.0  0.0 123360   728 ?        Ss   23:01   0:00 /usr/sbin/anacron -s
root      4089  0.0  0.0 112808   976 pts/1    R+   23:09   0:00 grep --color=auto cron

O PID Cron parece ser 1041, embora seja difícil dizer sem ver os cabeçalhos da mesa.Supondo que esse seja o caso, precisamos acessar a segunda coluna na primeira linha.O primeiro passo pode ser reduzir o espaço em branco excessivo:

ps -aux | grep cron | tr -s ' '

Isso rende:

root 1041 0.0 0.1 126384 1584 ? Ss 22:25 0:00 /usr/sbin/crond -n
root 3519 0.0 0.0 123360 728 ? Ss 23:01 0:00 /usr/sbin/anacron -s
root 4167 0.0 0.0 112808 972 pts/1 R+ 23:11 0:00 grep --color=auto cron

Agora podemos isolar a segunda coluna com cortar:

ps -aux | grep cron | tr -s ' ' | cut -d ' ' -f 2

Que produz:

1041
3519
4274

Finalmente, podemos pegar a primeira linha, como segue, para obter o resultado desejado, a saber, 1041:

ps -aux | grep cron | tr -s ' ' | cut -d ' ' -f 2 | head -1

Usando o fato de que os objetos de saída do PowerShell cmdlets, em vez de fluxos de dados, a versão PowerShell do acima é simplesmente:

(Get-Process -Name crond).Id

Nesse caso, Get -Process -Name Crond Retorna um objeto que representa o processo CRON.Este objeto possui uma série de propriedades úteis, uma das quais é o ID do processo (ou PID).Para acessar uma propriedade de um objeto PowerShell, você pode embrulhá -lo entre parênteses e, em seguida, usar a notação padrão "DOT", como mostrado.

Instalando o Linux PowerShell

Para instalar o PowerShell no seu sabor favorito do Linux, consulte a Microsoft's Instalando o PowerShell no Linux.Se sua distribuição Linux não estiver listada, considere Maneiras alternativas de instalar o PowerShell no Linux.

Como exemplo, os quatro comandos a seguir instalam a versão mais recente do PowerShell no CentOS 7:

# Optionally update all software packages:
  sudo yum -y update
  
# Register the Microsoft repository:
  curl https://packages.microsoft.com/config/rhel/7/prod.repo | sudo tee /etc/yum.repos.d/microsoft.repo
    
# Install PowerShell:
  sudo yum -y install powershell
    
# Start PowerShell:
  pwsh

Como pode ser visto, a instalação do PowerShell é direta.

Exemplos adicionais do Linux PowerShell

Uma técnica -chave é determinar quais propriedades um objeto PowerShell realmente possui.Isso pode ser facilmente realizado com o Get-membro cmdlet.Por exemplo, para determinar as propriedades de um objeto de processo PowerShell, você pode usar:

Get-Process | Get-Member -Force

Isso revela que há um Caminho propriedade para objetos de processo.Assim, podemos usá -lo para listar os 10 principais processos, com relação ao uso da CPU, como segue:

Get-Process | Sort-Object -Property CPU | Select-Object -Property Name, Path, CPU -Last 10

Isso produz saída semelhante ao seguinte:

Name           Path                                CPU
----           ----                                ---
xfwm4          /usr/bin/xfwm4                     1.95
systemd        /usr/lib/systemd/systemd           3.63
rngd           /usr/sbin/rngd                     7.39
xfce4-terminal /usr/bin/xfce4-terminal            9.35
xrdp           /usr/sbin/xrdp                    22.05
ksoftirqd/0                                      26.21
pwsh           /opt/microsoft/powershell/7/pwsh  27.37
rcu_sched                                        45.44
Xvnc           /usr/bin/Xvnc                     59.27
NetworkManager /usr/sbin/NetworkManager         955.19

Embora útil, podemos querer calcular uma métrica geral de uso do sistema.Um primeiro corte pode ser simplesmente somar os valores de memória não-gorda (NPM), memória da página (PM), conjunto de trabalho (WS) e uso de uso da CPU.Ou seja, definimos nossa métrica geral de uso da seguinte maneira:

Geralusage = npm + pm + ws + cpu.

Em PowerShell, isso pode ser realizado da seguinte maneira:

Get-Process | Select-Object -Property @{Label = 'OverallUsage'; Expression = {$_.NPM + $_.PM + $_.WS + $_.CPU}}

o @{} Tabela de hash (ou seja, pares de chave/valor) nos permite definir uma propriedade chamada GeralUsage cuja definição é a expressão mostrada acima.Nesta expressão, $_ representa um objeto de pipeline.Nesse caso, um processo de processo individual que Get-Process Retorna (um por processo Linux em execução).Em seguida, somamos as quatro propriedades.Isso resulta nas seguintes (primeiras linhas):

    OverallUsage
    ------------
          520192
       815104.03
          794624
         1093632
      4902912.01
      3330048.37

Agora podemos combinar esses dois conceitos da seguinte forma:

Get-Process | Select-Object -Property Name, Path, @{Label = 'OverallUsage'; Expression = {$_.NPM + $_.PM + $_.WS + $_.CPU}} | Sort-Object -Property OverallUsage -Bottom 10

Isso produz uma tabela de uso geral dos 10 melhores, semelhante ao seguinte:

Name                Path                             OverallUsage
----                ----                             ------------
Thunar              /usr/bin/thunar                    14073856.2
xfce4-power-manager /usr/bin/xfce4-power-manager       15970304.3
xfce4-panel         /usr/bin/xfce4-panel               16195584.9
xfdesktop           /usr/bin/xfdesktop                17588224.59
tuned               /usr/bin/python2.7                18898945.66
yum-cron            /usr/bin/python2.7                 22335488.2
xfce4-terminal      /usr/bin/xfce4-terminal            23642123.4
xrdp                /usr/sbin/xrdp                    26570776.34
Xvnc                /usr/bin/Xvnc                     82710598.14
pwsh                /opt/microsoft/powershell/7/pwsh 298852382.66

E se você preferir exibir valores de uso arredondados, pode usar:

Get-Process | Select-Object -Property Name, Path, @{Label = 'OverallUsage'; Expression = {[Math]::Round($_.NPM + $_.PM + $_.WS + $_.CPU)}} | Sort-Object -Property OverallUsage -Bottom 10

o [MATH] :: ROUND () A função é usada para arredondar as somas individuais para os valores inteiros mais próximos.

Conclusão

Existem muitos cenários em que os comandos padrão do Linux fazem mais sentido do que os cmdlets do PowerShell e, em vários casos, o contrário, mas o que é particularmente atraente é que você pode usar os dois paradigmas juntos.Como exemplo simples, considere:

Get-Process | Select-Object -Property Name, Path, Responding, Id |  grep cron

Isso produz:

anacron    /usr/sbin/anacron    True   3018
crond      /usr/sbin/crond      True   1033
yum-cron   /usr/bin/python2.7   True   4760

A terceira coluna indica se o processo é responsivo.

Como você pode ver, o PowerShell e a combinação de comandos PowerShell com o Linux oferecem ampla oportunidade para resolver e simplificar vários problemas e tarefas.