PowerShell? Lo usi? Puoi mostrarmi alcune cose interessanti sull'amministrazione del sistema che posso farci? [chiuso]

Continuo a leggere ovunque che PowerShell è la strada per il futuro. Quando è stato rilasciato la prima volta, ho fatto un sacco di laboratori virtuali, ma da allora non l'ho ancora usato in un ambiente di produzione. So che verrà il giorno in cui avrò a che fare con i sistemi operativi in ​​cui è già installato, quindi voglio essere pronto.

Voglio sapere:

1. Lo usi?
2. Qual è stato il processo di "bootstrap" per l'utilizzo di PowerShell?
3. Che tipo di attività di amministrazione del sistema hai scritto con esso?
4. Sono un amministratore del database di SQL Server. Quali sono alcune cose interessanti da fare con esso?

Sembra che tutti siano d'accordo sul fatto che Microsoft stia spingendo così tanto, ma nessuno lo sta ancora usando. Voglio sentire gli amministratori di sistema là fuori che lo usano per fare attività quotidiane e condividere alcuni esempi di codice.

Microsoft sta facendo tutto il possibile per rendere PowerShell la scelta di utenti esperti e scrittori di automazione ovunque. Sono finiti i giorni della compilazione del codice in .NET per fare la stessa cosa, ora hai solo bisogno di notepad.exe e google. Siamo grandi fan in ufficio, soprattutto perché la console di gestione di Exchange 2007 NON include tutto ciò che è possibile fare in PowerShell. Microsoft ha deliberatamente fallito nell'implementare cose che vengono fatte solo una volta ogni tanto, più facili da sviluppare in quel modo, il che ne costringe decisamente l'uso se hai qualcosa che assomiglia a un ambiente complesso.

La gestione della nuova generazione di prodotti Microsoft (Win7, Windows Server 2008, Exchange 2007/2010, SQL Server 2008) hanno tutti hook di PowerShell molto ricchi. Una volta che Remote Powershell (PowerShell 2.0 IIRC) viene distribuito con Server 2008 R2, diventerà ancora PIÙ utile per gli autori di automazioni.

Cosa ne abbiamo fatto:

• Creare una pagina Web per delegare determinate attività amministrative agli utenti dell'helpdesk. La pagina Web genera comandi che vengono eseguiti in PowerShell. Cose che fa:
  • Creare ed eliminare account utente, incluso il provisioning delle cassette postali e delle home directory di Exchange 2007
  • Sblocca gli account bloccati
  • Crea / elimina gruppi
  • Aggiungi / rimuovi utenti dai gruppi
  • Sposta gli utenti tra i negozi di posta
  • Imposta password
• Prendi estratti dal sistema ERP e trasferisci i dati della rubrica globale in Active Directory ogni notte.
• Risolvi il problema LegacyExchangeDN che è emerso con la nostra migrazione da Exchange 2003 a Exchange 2007. Ho dovuto aggiungere un indirizzo X500 a tutti quelli che erano su Exchange 2003. Uno script PowerShell abbastanza breve lo ha risolto.
• Creazione tramite script di "cassette postali di gruppo" (cassette postali condivise in Exchange in cui più utenti hanno accesso alla cassetta postale), un processo altrimenti manuale a causa della natura dei dati di cui abbiamo bisogno prima di dare il via. Ha standardizzato notevolmente l'installazione di queste cassette postali.
• Creato uno script che ha esaminato tutte le macchine di dominio ripristinando una chiave di registro specifica e riavviando un servizio. Ci sono volute 18 ore per il completamento, ma il lavoro è stato completato.

Quindi sì, PowerShell sarà con noi da un po 'di tempo.

EDIT : aggiunta di un esempio di codice, poiché è stato richiesto

$ List = Import-CSV ( "groupusers.csv")
$ Lastseengroup = $ list [0] .group
$ ADGroupPrefix = "grp.netware."
$ ADGroupSuffix = "{redatto - nel formato di, ou = gruppi, dc = dominio, dc = dominio, dc = dominio}"
Elenco dei membri Clear-Variable
Utenti sconosciuti a variabile libera
foreach ($ entry in $ list) {
    if ($ ($ entry.group) -ne $ lastseengroup) {
        echo "inciampato nel nuovo gruppo $ ($ entry.group), eseguendo le modifiche in $ lastseengroup"
        $ Newgroup = $ ADgroupPrefix + $ lastseengroup
        $ Newgroupdn = ' " '+ "cn = $ newgroup $ ADGroupSuffix" +'"'
        echo "ottenere DN per $ newgroup"
        $istinggroup = gruppo dsquery domainroot -name $ newgroup
        if (($istinggroup -ne $ null)) {
            dsmod group $ newgroupdn -chmbr $ memberlist
        } altro {
            gruppo dsadd $ newgroupdn -scope u -secgrp yes -members $ memberlist -desc "Gruppo importato da eDirectory"
        }
        Elenco dei membri Clear-Variable
    }
    $ User = get-user $ ($ entry.member) -ErrorAction SilentlyContinue
    if ($ User.isvalid) {
        $ DNUtente = $ User.distinguishedname
        $ memberlist = $ memberlist + '"' +" $ UserDN "+ '"'
    } altro {
        $ unknownusers = $ unknownusers + $ ($ entry.member)
    }
    $ Lastseengroup = $ ($ entry.group)

}
gruppo dsadd "cn = $ ADGroupPrefix $ lastseengroup $ ADGroupSuffix" -scope u -secgrp yes -members $ memberlist

Questo prende un file CSV creato con uno script perl e aggiorna una serie di gruppi. Se il gruppo esiste già, sostituisce l'appartenenza con quella specificata nel file. Se il gruppo non esiste, lo crea. Questa è una sincronizzazione unidirezionale. Inoltre, non ancora in produzione, ma vicino.

Dato che i prodotti server di Microsoft saranno abilitati a PowerShell fin dall'inizio (credo che la prossima versione di Exchange abbia tutte le configurazioni disponibili tramite PowerShell) e che libri come PowerShell in Practice descrivono alcuni ottimi modi per automatizzare attività altrimenti monotone, penso è ragionevole suggerire che PowerShell sarà una tecnologia diffusa nel server Windows per un po '.

Consiglierei il podcast # 162 di Scott Hanselman . Sembra che tutti i team di server Microsoft siano "costretti" a fornire i cmdlet di PowerShell e anche a seguire un'unica sintassi coerente.

Inoltre, terze parti come VMWare lo stanno adottando

In breve, credo che PowerShell a partire dalla 2.0 sia seriamente destinato alla sostituzione di file batch per tutti tranne i compiti più banali.

Dieci script PowerShell che utilizzo come amministratore del database SQL Server (tutti sono descritti / pubblicati sul mio blog ):

1. Controlla lo spazio su disco su tutti i server SQL e carica i dati in una tabella SQL
2. Eseguire report delle autorizzazioni su tutti i server SQL di produzione e caricare i dati in un database SQL
3. Scopri tutti i cluster, i nodi e i virtuali di Windows Server 2003 in rete e carica su tabelle SQL
4. Scopri tutti i database su tutti i server SQL come definiti in SCCM e carica su una tabella SQL
5. Creare una scorecard di backup di SQL Server caricando le informazioni di backup su tutti i server SQL in una tabella SQL
6. Verificare che TCP Offload Engine sia disabilitato in Windows Server 2003 SP2 (questo è un killer delle prestazioni per molti server SQL)
7. Verifica degli allineamenti delle partizioni del disco (anche un killer delle prestazioni se i dischi non sono allineati in modo errato)
8. Copia le tabelle SQL da un server a un altro
9. Recursivley copia tutti i pacchetti SSIS utilizzando un archivio MSDB da un server a un altro, inclusa la struttura delle cartelle
10. Crea il mio visualizzatore di dipendenze di oggetti grafici

Che tipo di attività di amministrazione hai scritto con esso?

monitoraggio di applicazioni / servizi: ricava i numeri delle prestazioni chiave da EventLog (remoto) e Stored procedure e li visualizza da un singolo file batch

Sono un DBA di SQL Server, mostrami alcune cose interessanti da fare con esso?

automssqlbackup : backup giornaliero per MSSQL con rotazione (giornaliero = incrementale, settimanale + mensile = pieno; mantenere 5 backup giornalieri, 5 backup settimanali), zippare, notifica e-mail

Avendo usato gli script di shell unix in una carriera precedente, passando poi all'amministrazione di Windows Server, posso dire che apprezzo molto PowerShell - non ho tempo né capacità di apprendere troppa sintassi arcana e sono rimasto piacevolmente sorpreso molto degli script PowerShell può essere scritto con un linguaggio molto semplice ... prendi quello che vale come ero abituato a ksh !!

Prevedo che rimarrà per molto tempo.

Ho pensato che fosse bello: con SQL Server 2008 ottieni nuove estensioni di PowerShell che ti consentono di navigare nei database SQL proprio come il tuo file system o registro locale.

Dopo aver installato gli strumenti client di SQL Server è possibile aprire qualsiasi database in PowerShell (tramite il menu contestuale del tasto destro) e giocare con esso in modo orientato agli oggetti:

PS SQLSERVER:\SQL\MyServer\MyInstance\Databases\ExampleDB\>function prompt {"PS >"}
PS >cd tables
PS >dir

SCHEMA          NAME         CREATED
------          ----         -------
dbo             MyTable      25/06/2009 17:02

PS > dir | format-table name, columns, rowcount, parent

NAME            COLUMNS      ROWCOUNT      PARENT
----            -------      --------      ------
MyTable         {Id, Name}   0             {ExampleDB}

PS >$myTable = dir | where {$_.Name -eq "MyTable"}
PS >$myTable.Script()

SET ANSI_NULLS ON
SET QUOTED_IDENTIFIER ON
CREATE TABLE [dbo].[MyTable](
[Id] [int] IDENTITY(1,1) NOT NULL
[Name] [nText] NOT NULL
) ON [PRIMARY]

PS >set-location \SQL\AnotherServer\Default
PS >cd databases\Northwind\tables
PS >$myTables = dir | where {$_.Rowcount -gt 100 -and $_.HasIndex -eq 1}
PS >$myTables.Count

8

PS >foreach ($table in $tables) {$table.RebuildIndexes(90)}

Nota che la prima riga cambia semplicemente il prompt in modo che non sia così lungo.

Spero che a parte ciò sia evidente cosa sta succedendo qui :)

SQL Server 2008 ora ha opzioni di contesto PowerShell in Management Studio, quindi più di Exchange lo sta abbracciando. Inoltre, pensalo come il sostituto di DOS, poiché è praticamente quello che pensava MS in quanto non potevano migliorare la sicurezza del DOS per problemi di compatibilità con le versioni precedenti, quindi hanno appena creato qualcosa di nuovo e wammo, il problema è stato risolto!

Anch'io sono un DBA e uno scripter da molto tempo, tornando ai file batch DOS, V3.3! Passato a VB Script ma PS è molto potente. Dai un'occhiata a - Mi dispiace, non riesco a pubblicare il link, poiché sono un nuovo utente. L'ho preso dal blog di Otto Helweg. È uno strumento di inventario software economico e allegro.

• 1- Estrae l'elenco dei computer da interrogare da una tabella del database
• 2- Aggiunge i dati e il tempo correnti al risultato
• 3- Registra i risultati del controllo in un database

Esempio di script di PowerShell:

# Open the database connection
$dbConn = new-object System.Data.SqlClient.SqlConnection "server=kcdb;database=Inventory;Integrated Security=sspi"
$dbConn.Open()
$sqlQuery = $dbConn.CreateCommand()

# Get all known computers
$sqlQuery.CommandText = "select * from Inventory..Computers"
$reader = $sqlQuery.ExecuteReader()
$computersToQuery = @()
while ($reader.Read()) {
   $computersToQuery += $reader["Computer"]
}

# Close the database connection
$dbConn.Close()

$softwareInventory = @{}
foreach ($computer in $computersToQuery) {
   $psinfoOutput = ./psinfo.exe -s Applications \\$computer

   $foundSoftwareInventory = 0
   $computerName = ""
   foreach ($item in $psinfoOutput) {
      if ($foundSoftwareInventory -eq 1) {
         # Force the results to a string
         # Remove any single quotes which interfere with T-SQL statements
         # Load the result into a hash whereby removing any duplicates
         [string]$softwareInventory[$computerName][$item.Replace("'","")] = ""
      }

      if ($item -like "System information for *") {
         $computerName = $item.Split("\")[2].TrimEnd(":")
      } elseif ($item -eq "Applications:") {
         $foundSoftwareInventory = 1
         $softwareInventory[$computerName] = @{}
      }
   }
}

$dbConn = new-object System.Data.SqlClient.SqlConnection "server=kcdb;database=Inventory;Integrated Security=sspi"
$dbConn.Open()
$sqlQuery = $dbConn.CreateCommand()

foreach ($computer in $softwareInventory.Keys) {
   foreach ($softwareItem in $softwareInventory[$computer].Keys) {
      "Loading-" + $computer + ":" + $softwareItem

      # Try an Update then an Insert 
      trap {
         $sqlQuery.CommandText = "update Inventory..SoftwareInventory set AuditDate = getdate() where  Computer = '" + $computer + "' and Software = '" + $softwareItem + "'"
         $result = $sqlQuery.ExecuteNonQuery()
         continue
      }

      $sqlQuery.CommandText = "insert into Inventory..SoftwareInventory (Computer,Software,AuditDate) values ('" + $computer + "','" + $softwareItem + "',getdate())"
      $result = $sqlQuery.ExecuteNonQuery()
   }
}

$dbConn.Close()

Dave J

Le seguenti attività sono svolte dal mio team su base regolare con PowerShell

• elenca la memoria disponibile su tutti i nodi dei nostri cluster Hyper-V.
• Gestisci un filer Netapp
• Fornire nuove macchine virtuali Hyper-V
• Scrivere e leggere dagli elenchi di SharePoint a livello di codice

Ogni giorno, ho sempre un prompt di PS che lo uso e lo uso per qualsiasi attività una volta che ho usato per usare CMD.

Ecco alcuni esempi di codice per la lettura degli elenchi di Sharepoint. Uso i servizi Web di Sharepoint e il nuovo cmdlet "New-WebServiceProxy" in PowerShell V2.0

$url = "http://server/sites/site/_vti_bin/lists.asmx"
$listWebService = new-webServiceProxy -uri $url -UseDefaultCredential
$listName = "MyList"
$viewGuid = $null
$query= $null
$viewFields = $null
$numRowsReturned = 20000
$queryOptions = $null
$result = $listWebService.GetListItems($listName,$ViewGuid,$query,$viewFields,$numRowsReturned,$queryOptions,$null)

Oisin Grehan ha pubblicato un bellissimo post sul blog sull'utilizzo dei servizi Web Sharepoint che ho usato come base per creare tutte le mie funzioni. Ha anche un fantastico script new-webservice.ps1 che puoi usare se stai ancora usando PowerShell V1.

Inoltre, ecco la funzione di base che ho usato per ottenere la memoria disponibile sui nodi nel mio cluster

Function Get-AvailableMemory {
param
(
[string[]]
$servers
)
BEGIN {
$query = "select AvailableBytes,__SERVER from Win32_PerfRawData_PerfOS_Memory"

$availableMemory = @{
                    Name="AvailableMemory";
                    Expression = {[math]::round($_.AvailableBytes/1gb,2)}
                    }
$serverName = @{  
                Name ="Server";
                Expression = {$_."__SERVER"}                                      
               }
}
PROCESS {
foreach ($server in $servers){
    get-wmiobject -query $query -computer $server |
    select-object $availableMemory, $serverName
    }
}

END {}    

}

Ho provato PowerShell per un piccolo progetto al lavoro: una migrazione giornaliera di un sottoinsieme di ~ 600 utenti e ~ 200 gruppi dall'AD aziendale a un vecchio sistema UNIX utilizzando file simili a CSV . Mi è stato offerto uno script VBScript a 500 righe (!) Che ha estratto un singolo gruppo e i suoi utenti come punto di partenza.

Si è scoperto che uno script di PowerShell a 20 righe potrebbe fare tutto ...

Come utente * NIX (lato server e client), sono stato piacevolmente sorpreso da PowerShell. Anche se conosci solo un piccolo sottoinsieme di comandi, puoi fare un lavoro davvero potente con esso. Ho solo bisogno dell'accesso remoto SSH (-like) ...

Come posso non usarlo? Tutte le applicazioni server Microsoft in uscita / in fase di aggiornamento sono ora gestite tramite Powershell. Alcune UI / Management Console più o meno fastidiose vengono quindi fornite sulla base di questo core che spesso è lento e, come qualcuno ha sottolineato, manca di funzionalità disponibili ... quindi non posso dire che in realtà abbiamo molta scelta ^ ^

Powershell non è perfetto ma se l'hai usato sai che è piuttosto bello. Avere accesso all'intera libreria .net più i cmdlet integrati (e creare i tuoi cmdlet usando PS in 2.0), è piuttosto interessante.

L'unica cosa che penso manchi è un buon IDE per questo che sono sicuro che verrà dalla SM un giorno. In questo momento uso PowerShell Plus di Idera e admininscripteditor che consentono il debug e sono piuttosto interessanti.

Sono stato in grado di liberarmi abbastanza bene da VB.

Il mio più grande progetto fino ad oggi con posh è usare "powershellASP" per creare una pagina Web di base che esegua i comandi PowerShell e tira le informazioni sull'host vmware e sulla VM dai miei più di una dozzina di host ESXi (gratuiti) VMWare e li visualizzi in tabelle HTML. L'ho fatto perché con VMWare ESXi gratuito e nessun centro virtuale, non c'è altro modo per ottenere una panoramica in tempo reale di tutte le mie macchine virtuali dell'azienda. PowershellASP è un parser di terze parti gratuito scritto per IIS e non supportato da MS. Quindi può fare alcune cose limitate in questo momento e la documentazione è piuttosto scarsa.

Ho un sacco di script di gestione / inventario che cercano in AD cose diverse e li interrogano su WMI per statistiche vitali come condivisioni sul server, spazio su disco, spazio su disco usato, ecc.

Script generali:

1. Ottieni spazio libero / usato su disco, RAM, ecc.
2. Richiesta WMI per informazioni BIOS, modello di creazione server, ecc.
3. Controlla la versione AV e assicurati che ci siano alcune voci di registro
4. Condivisione del controllo sui server Windows

Script utente:

1. Enumera AD prendendo tutti gli utenti e quali gruppi appartengono, quindi scrivi in ​​Excel o CSV
2. Trova gli utenti attualmente connessi tramite TS e sulla console

Ne ho uno che elenca tutte le macchine guest VMWare sui miei server ESX

Ho uno script che prende i file dopo x giorni e li elimina in modo sicuro.

Fondamentalmente posso fare ciò che ha richiesto circa 200 righe di VBScript e farlo in 10 di PowerShell. Puoi anche fare cose che non riesci a fare o fare bene in VBScript - come inviare e-mail con allegati - cosa che faccio regolarmente per inviarmi i risultati dei miei script. Inoltre, è possibile scrivere voci significative e uniche nel registro eventi con nomi di servizio personalizzati e ID evento.

Questo è quello a cui riesco a pensare dalla cima della mia testa. Il mio strumento preferito è PowerShell ora, mi semplifica la vita.

Fondamentalmente è utile per un amministratore di sistema tanto quanto lo script di Bash è per un amministratore Unix.

Stavo guardando Poweshell per sostituire i nostri script batch client: programmi in esecuzione, script di accesso ecc.

Ma ho scoperto che ha aggiunto almeno 10 secondi al tempo di accesso - questo è con tutte le "modifiche" in atto. Quindi abbiamo finito con quello che stavamo usando.

Non essendo uno sviluppatore .NET, ho un uso limitato per tutti i gadget correlati a .NET che PS ti consente di utilizzare. Tuttavia, essendo un amministratore di Exchange (tra le altre cose), l'integrazione di PowerShell per Exchange 2007 è FANTASTICA. Finalmente ho un motore di scripting affidabile per il mio sistema di posta; finora, ho ricevuto l'invio di statistiche mensili sulle cassette postali di tutti, regolando a chi sono assegnati vari indirizzi e-mail in base all'ora del giorno, creando e assegnando automaticamente le autorizzazioni alle cartelle pubbliche e bilanciando il carico degli utenti tra i nostri due DB di cassette postali . L'altra cosa interessante dal punto di vista di Ex07 è che dopo aver fatto qualsiasi cosa nella GUI, ti presenta i comandi PowerShell pertinenti per quello che hai appena fatto. Copia quelli e alla fine avrai una serie di script PS che possono ripristinare il tuo ambiente Exchange da zero.

Automatizzare determinate cose con i controlli del server in cui lavoro (raccolta di informazioni di base da WMI e raccolta di errori e avvisi dai registri degli eventi).

La gestione dei registri eventi è eccezionale.

Di recente ho scritto uno script per disabilitare il popup di aggiornamento automatico che Foxit Reader ha abilitato per impostazione predefinita in un dominio su cui viene eseguito lo script. Estrae un elenco di computer da AD, quindi verifica se è attivo, quindi cambia da 1 a 0.

Una cosa che ho dimenticato!

Hai praticamente pieno accesso alle librerie .NET. È un po 'doloroso fare cose davvero complicate, ma se ne hai bisogno, è lì per te.

Lo usiamo per alcune attività amministrative, essendo principalmente un negozio Microsoft. Alcuni script sono semplici, come la pulizia di vecchi file o la deframmentazione delle macchine e la registrazione dei risultati. Uno script controlla i computer utilizzando principalmente WMI e registra i risultati in un database. Ottiene elementi quali hardware (CPU, RAM, unità, ecc.), Informazioni di rete, utenti locali, software installato e informazioni sul profilo. Ce n'è uno che chiama un servizio web per inviare e-mail. Penso che in futuro sostituirà il resto degli script VBScript che sono ancora in uso. Non lo stiamo ancora utilizzando per le attività di Exchange o SQL Server.

Non vedo l'ora che arrivi la prossima versione, che supporterà i lavori in background, le transazioni, una migliore gestione delle eccezioni, un nuovo ISE (Integrated Scripting Environment), un migliore debug, ecc.

I miei amministratori di Windows non usano ancora PowerShell. Ne hanno sentito parlare tutti, ma non hanno avuto il tempo di familiarizzare con esso.

Ho deciso di dare un'occhiata a me stesso. Provenendo da un background di shell Unix, ho pensato che Windows dovesse finalmente avere un vero ambiente di programmazione shell. Penso che Microsoft abbia fatto alcune cose bene con PowerShell e qualcosa non così bene.

Il lato positivo è il loro uso di oggetti come intermediario tra i cmdlet in PowerShell. Questo porta un livello di potenza in PowerShell che gli script basati su testo devono hackerare per mettersi al lavoro.

Sul lato negativo, in realtà non sfruttano gran parte dei comandi della shell Unix. Quindi la curva di apprendimento è inutilmente ripida e non aiuta le persone a spostarsi facilmente da Unix a PowerShell o viceversa. Il più che fanno è definire alias per alcuni dei PowerShell cmdlet come ls aliasing Get-ChildItem con tutto il della riga di comando essendo diverso.

Solo i miei due centesimi ...

Questa è più una risposta dello sviluppatore, ma è il mondo reale e inizieremo a testarlo ad un certo punto nei prossimi mesi. Sto iniziando a imparare PowerShell per scrivere script per portare le attività di SQL Server nel nostro ambiente di integrazione continua . Gli script di integrazione continua saranno eseguiti principalmente da NAnt e MSBuild tramite JetBrains TeamCity .

Inoltre, sto cercando di passare a PowerShell come shell di comandi principale di Windows per scopi generali e in particolare per le attività di amministrazione del database di SQL Server.

Spiacenti, non ho ancora esempi di codice da condividere, perché sto ancora imparando! Sarò felice di postarne qualcuno quando lo farò, però :)

Ecco un esempio di codice a riga singola con cui ho appena risposto a un'altra tua domanda :) Ma hey, per il wiki ...

Questo elencherà gli aggiornamenti rapidi installati:

Get-ChildItem -Path “HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\HotFix”

Sebbene non sia il linguaggio di script più facile da imparare (solida esperienza con le pipe presunte) e ha una sua leva di stranezze (dammi un semplice aspetto da sed !!), trovo che PowerShell sia abbastanza potente. Non fino al livello di Bash o altre shell Unix, ma comunque.

Lo uso per supervisionare alcune esportazioni e importazioni di database con avvisi via e-mail nel caso in cui le cose vadano male e faccio alcune operazioni batch di routine.

Certamente è già la mia shell principale di Windows, anche se in realtà non è il tipo di cose "scrivi meno fai di più". PowerShell ha la sua verbosità (e l'eredità .NET) che gioca contro di essa.

La versione 1.0 di PowerShell era fortemente limitata in molti aspetti, ma la versione 2.0 sta andando bene. Rispetto agli script batch, è molto più potente. Non lo uso davvero come shell, solo per gli script, quindi la mia esperienza è colorata di conseguenza. Non mi piace molto la sintassi ( -eqvs ==, -gtvs >, ecc.), Ma apprezzo essere in grado di accedere a .NET se devo fare qualcosa di strano. Penso che dalla versione 3.0 sarà eccezionale. In questo momento lo metterei saldamente nella categoria di "ottenere il lavoro fatto".

Lo uso principalmente per automatizzare la distribuzione del codice. Questa è un'area in cui brilla nel creare qualcosa in C #. Le operazioni relative alla shell come la copia ricorsiva di directory e altre cose che gli scripter di Bash danno per scontate da anni rendono le cose molto più facili.