Aprenda o Microsoft Azure do Zero Curso Gratuito

>> O link será enviado via Whatsapp, Para receber o link do curso preencha o campo ao lado.

Powershell Leonardo Duarte

Cmdlets, aprenda Como Utilizar os Cmdlets no Powershell

Um cmdlets – pronunciado comando-let – é um comando pequeno e leve que é usado no ambiente Windows PowerShell. Um cmdlet normalmente existe como um pequeno script que se destina a executar uma única função específica, como lidar com arquivos e alterar diretórios. Um cmdlet e seus parâmetros relevantes podem ser inseridos em uma linha de comando PowerShell para execução imediata ou incluídos como parte de um script PowerShell mais longo que pode ser executado conforme desejado.

Como funcionam os cmdlets?

Os cmdlets empregam um padrão de nomeação verbo/substantivo que é projetado para tornar cada cmdlet mais fácil de lembrar e ler. Como exemplo, um comando típico do Get-ChildItem usa o verbo Get seguido pelo substantivo ChildItem. Quando executado através do ambiente de tempo de execução do PowerShell, o comando lista ou retorna os itens em um ou mais locais especificados. Se os itens estiverem em um recipiente, o comando recebe os itens dentro do recipiente – itens infantis.

Os cmdlets são baseados em classes .NET e dependem do uso de objetos .NET. Assim, os cmdlets podem receber objetos como entrada e entregar objetos como saída, o que pode então alimentar a entrada de objetos subsequentes, permitindo que os cmdlets formem um pipeline de comando.

A maioria dos cmdlets suporta o uso de parâmetros como parte do mecanismo de entrada. Os parâmetros podem ser adicionados ao cmdlet na linha de comando ou passados para cmdlets como a saída de um cmdlet anterior. Os argumentos ou valores de cada parâmetro detalham a entrada real que o cmdlet aceitará, como o cmdlet deve funcionar e o que – se houver – dados das saídas de cmdlet. Switches são argumentos especializados que oferecem opções ou seleções predefinidas.

Considere um cmdlet simples, como Get-Help; a sintaxe do cmdlet para obter ajuda para cmdlets desejados de uma biblioteca online é:

get-help <cmdlet-name> -online

Get-Help é o cmdlet. O argumento do parâmetro <cmdlet-name> é o nome do cmdlet que precisa de mais informações. No uso real, os usuários substituiriam o nome do cmdlet desejado. Pode ser qualquer cmdlet. O switch é -online, que diz ao PowerShell para fazer referência e devolver ajuda para o cmdlet desejado da biblioteca online da Microsoft. Por exemplo, para obter mais ajuda sobre o cmdlet Add-AppxPackage, o comando PowerShell seria assim:

get-help add-appxpackage -online

Para usar ajuda local para o mesmo cmdlet, elimine o interruptor:

get-help add-appxpackage

cmdlets

Cmdlets vs Funções

Embora o PowerShell dependa do processamento de cmdlets, há um segundo tipo de comando chamado funções. As funções também são interpretadas através do PowerShell e são rotineiramente usadas em scripts. É comum confundir cmdlets e funções. No entanto, cmdlets e funções diferem de várias maneiras importantes.

Cmdlets são classes .NET escritas em linguagens de programação superior, como C# e compiladas em arquivos .dll para que o PowerShell possa acessá-los. Assim, os conjuntos de cmdlet podem ser facilmente adicionados e novos cmdlets podem ser criados e disponibilizados para o PowerShell. Em comparação, as funções tendem a ser integradas ao PowerShell e não são compiladas, mas escritas na linguagem PowerShell. As funções tendem a ser entidades mais longas e complexas que normalmente podem lidar com análise, apresentação de erros e formatação de saída, onde cmdlets são muitas vezes muito pequenos e simples para lidar com tais detalhes.

Ainda assim, a diferença essencial entre cmdlets e funções está em tais questões de embalagem, incluindo configuração, instalação e recursos. Na prática, há pouca diferença perceptível entre cmdlets e funções. Como os cmdlets, as funções podem ter parâmetros e valores de retorno que podem ser exibidos ou atribuídos a variáveis. Ambos os cmdlets e funções são facilmente usados em scripts PowerShell.

Cmdlets populares

Existem centenas de cmdlets disponíveis por padrão sob o PowerShell de hoje, e centenas de cmdlets a mais podem ser adicionados ao PowerShell para suportar aplicativos avançados, como plataformas de virtualização e ferramentas de gerenciamento de sistemas. Para encontrar um índice completo de todos os cmdlets que estão atualmente disponíveis no PowerShell em um computador, digite:

get-command -commandtype cmdlet

Isso retorna uma lista completa de cmdlets atualmente no PowerShell. No entanto, isso não fornece detalhes específicos sobre a finalidade ou sintaxe de cada cmdlet. Para obter mais detalhes sobre os cmdlets desejados, use o cmdlet Get-Help como descrito acima. Por exemplo, para aprender o nome, sintaxe, pseudônimos e notas sobre o cmdlet Unblock-File, use:

get-help unblock-file

e o PowerShell retorna exemplos completos de sintaxe e parâmetros adequados. Os usuários do PowerShell geralmente se beneficiam se familiarizando com uma seleção de cmdlets PowerShell comumente usados, que incluem:

 

cmdletFunction
Get-Locationobter o diretório atual
Get-ChildItemitens listar em um diretório
Get-Helpobter mais informações sobre um cmdlet desejado
Stop-Processencerrar um processo PowerShell
Set-Locationmudar o diretório atual
Copy-Itemcopiar arquivos
Remove-Itemremover um arquivo ou diretório
Move-Itemmover um arquivo
Rename-Itemrenomear um arquivo
New-Itemcriar um novo arquivo vazio ou diretório
Invoke-GPUpdateforçar uma atualização política de grupo
Stop-Computerdesligar um computador local ou remoto
Restart-Computerreiniciar um computador local ou remoto
Add-Computerjuntar um computador a um domínio

 

Como escrever um simples cmdlet

Cmdlets são tipicamente entidades simples e podem ser escritas em apenas várias dezenas de linhas de C# ou outras linguagens que suportam código de objeto .NET . Embora o trabalho real e a complexidade de um cmdlet possam variar drasticamente, o processo real envolvido na delineação de um novo cmdlet geralmente pode ser dividido em várias etapas comuns que envolvem definir o cmdlet, aceitar parâmetros e, em seguida, processar os parâmetros para fornecer uma saída. Um exemplo simples pode ser criar um cmdlet que pegue o nome de uma pessoa e gere uma mensagem de teste.

1. Como se trata de um cmdlet, o desenvolvedor está basicamente criando um objeto, então primeiro especifique a classe pai para o cmdlet. Um cmdlet deriva das classes System.Management.Automation.Cmdlet ou System.Management.Automation.PSCmdlet. Um cmdlet em C# pode usar o comando de uso como:

using System.Management.Automation;

2. Em seguida, especifique o nome da classe objeto. Por exemplo, se o novo cmdlet for simplesmente enviar uma mensagem de teste, C# pode usar o comando namespace, tais como:

namespace SendTestMessage

3. Declare a classe do objeto como um cmdlet. O atributo cmdlet permite que os desenvolvedores estipulem os elementos verbo e substantivo do nome cmdlet. Por exemplo, um comando C# que define um cmdlet e o nomeia de “Enviar-Teste” pode aparecer como:

[Cmdlet(VerbsCommunications.Send, "TestMessage")]

4. Especifique quaisquer parâmetros para o cmdlet usando o atributo parâmetro. O comprimento e a complexidade desta seção de código dependem do número e dos tipos de parâmetros que o cmdlet se destina a manusear. Por exemplo, se o cmdlet é apenas destinado a aceitar o nome de uma pessoa para receber uma mensagem de teste, um parâmetro pode ser inserir o nome desse indivíduo e criar o “nome” da sequência variável. Em C#, a sequência de código pode aparecer como:

[Parameter(Mandatory=true)]
    public string Name
    {
      get { return name; }
      set { name = value; }
    }
    private string name;

5. Agora que o cmdlet foi definido e aceito parâmetros, o código do cmdlet pode se concentrar na tarefa real em questão. Neste caso, a tarefa é levar o parâmetro de nome e a saída desse nome para uma mensagem de teste simples. Como exemplo, o comando WriteObject pode produzir uma saída simples, como:

     {
      WriteObject("It is good to meet you " + name + "!");
     }

Lembre-se que este é apenas um exemplo simples e não detalha todos os comandos, pontuação – recuando e suporte – e código de suporte que pode ser necessário para completar tal cmdlet com sucesso. Os desenvolvedores podem consultar a documentação C# e PowerShell, textos detalhados sobre a criação de cmdlets e inúmeros exemplos de cmdlets para mais orientação de programação.

Sobre o autor | Website

Meu nome é Leonardo Duarte sou profissional de TI com mais de 18 anos de experiência em produtos da Microsoft. Possuo diversas certificações: MCP/MCT/MCTS/MCSA/MCSE

Que tal um Curso Microsoft Gratuito com Certificado Internacional? Não fiquede fora junte-se aos 1100 alunos já inscritos.

Aprenda o Microsoft Azure do Zero - Curso Gratuito Para receber o link do curso preencha o campo abaixo.

Por gentileza, se deseja alterar o arquivo do rodapé,
entre em contato com o suporte.