Automatizzare compiti con PowerShell PSake: un’analisi approfondita

Quindi hai imparato come automatizzare compiti con uno script PowerShell.
Questo è fantastico! Ma ora hai una confusione di script e moduli con una serie di esecuzioni manuali degli script, attività programmate e altro ancora. È ora di mettere ordine nel caos e implementare il motore di orchestrazione dell’automazione noto come PowerShell PSake.

PSake è un motore di orchestrazione scritto come modulo PowerShell che aggiunge ordine ai tuoi script e ti dà pieno controllo su cosa viene eseguito quando e in quali condizioni. Anche se PSake è uno strumento di automazione della compilazione e il suo caso d’uso principale è negli script di compilazione (di solito eseguiti da un server di compilazione in scenari di automazione dei rilasci), di solito viene trascurato negli scenari di scripting quotidiano. Cambiamo questa situazione.

In questo tutorial, imparerai come funziona PSake insieme a alcuni ottimi esempi da mettere in pratica oggi stesso!

Prerequisiti

Questo articolo è un tutorial che si aspetta che tu segua passo dopo passo. Se vuoi seguire tutto esattamente come descritto, assicurati di avere:

• Windows PowerShell 3+. Il tutorial utilizza Windows PowerShell v5.1
• Il file zip di PSake da Github. Questo tutorial utilizza la versione 4.9.0.

Configurazione del modulo PSake

Assumendo che tu abbia il progetto PSake da GitHub sul tuo computer locale, dovrai prima eseguire alcuni passaggi per configurarlo.

1. Esttrai il file zip di PSake scaricato da GitHub.
2. Sposta la cartella src all’interno dei contenuti estratti del file ZIP in un percorso sotto $env:PSModulePath per assicurarti che PowerShell sia a conoscenza del nuovo modulo.
3. Rinomina la cartella src in PSake.
4. Ora esegui Get-Module PSake -ListAvailable per confermare che appaia. Se non ricevi un errore, sei pronto per procedere.

Correlato: Comprensione e creazione di moduli di PowerShell

Creazione di uno script di base di PowerShell PSake

Per capire PSake, è necessario costruire qualcosa. Creiamo uno script PSake semplice per vedere cosa può fare.

1. Crea uno script chiamato psakefile.ps1 con un unico compito. Almeno, un compito dovrebbe avere un nome e un blocco di azioni. Il nome psakefile.ps1 non è obbligatorio, ma è il nome predefinito previsto dall’engine.

A PSake task in its basic form is very similar to a PowerShell function:
a container for one or more commands that, when performed together, achieve a certain goal. These commands go into a script block that is passed to the Action parameter. A task has many advantages over a function. You will learn about these advantages as you read along.

Ecco un esempio di un psakefile.ps1 con un compito piuttosto semplice:

task HelloWorld -Action {
    Write-Host '*** Hello World ***' -ForegroundColor Yellow
}

2. Ora che hai creato il file PSake, puoi chiamarlo da una console di PowerShell con il comando Invoke-PSake e passare il nome del compito come valore al parametro TaskList .

Invoke-PSake è il motore di esecuzione per PSake. Questo comando avvia i compiti definiti in psakefile.ps1. Passi un nome di compito o un elenco di compiti separati da virgole al parametro TaskList. Se esegui più compiti, ogni compito verrà eseguito nell’ordine in cui li hai passati a TaskList, indipendentemente dalla loro posizione in psakefile.ps1.

Di seguito è riportato come puoi avviare il compito HelloWorld:

Invoke-PSake -BuildFile C:\Work\psakefile.ps1 -TaskList 'HelloWorld'

Finché mantieni il nome psakefile.ps1 e imposti la console nella cartella in cui si trova, puoi omettere il parametro BuildFile e il suo valore.

3. Eseguendo Invoke-PSake verrà mostrato l’output di PSake nella console. Quando esegui i compiti in psakefile.ps1, vedrai un output simile a quello riportato di seguito.

L’output è composto da questi componenti:

1. I dettagli sulla versione di PSake.
2. Il nome di ogni compito di build prima che venga eseguito (PSake considera ogni compito come un compito di build ). Nell’esempio: Esecuzione di HelloWorld in ciano.
3. Ogni output prodotto dal compito. Nell’esempio: Hello World in giallo.
4. Messaggio di successo/fallimento. Nell’esempio: psake ha avuto successo… in verde.
5. Riepilogo del tempo (chiamato Rapporto sul tempo di compilazione) con la durata di ogni compito, più la durata totale di tutto lo script.

Installazione di SQL con PSake

Nella sezione precedente, non hai fatto molto oltre ad avviare uno script PSake fittizio. Ora costruisci su quella conoscenza e crea uno script PSake che installa SQL!

In questo esempio, creerai uno script PSake che:

1. Verifica lo spazio libero su disco di una macchina.
2. Scarica un file SQL ZIP da un repository locale.
3. Estrae il file ZIP.
4. Esegue l’installazione sull’unità C o D (quella dei due che esiste).

Vediamo ora come possiamo utilizzare PSake per questo compito.

Progettazione dei blocchi di costruzione

PSake si basa sull’orchestrazione delle attività. Ogni attività dovrebbe avere un nome univoco e idealmente dovrebbe eseguire un’operazione atomica singola come una funzione di PowerShell. Utilizzando questo concetto, puoi descrivere i passaggi seguenti per creare un’attività per ciascuno.

1. ValidateDiskSpace
2. DownloadSql
3. ExtractSql
4. InstallSqlDriveC
5. InstallSqlDriveD

A questo punto, non stai effettivamente costruendo il codice per fare qualcosa; stai semplicemente creando la struttura delle attività e creando il file PSake. Noterai i riferimenti Write-Host nelle attività seguenti; aggiungerai del codice alle attività in seguito.

Dovresti sempre utilizzare il parametro Description per ogni attività. Il parametro Description fornisce ulteriori informazioni su ogni attività sia durante l’esecuzione delle attività che durante la revisione del codice.

task ValidateDiskSpace -Description 'Validate Disk Free Space' -Action {
	
	Write-Host "`n   *** Checking disk free space ***`n" -ForegroundColor Yellow
	
}

task DownloadSql -Description 'Download SQL Setup' -Action {
	
	Write-Host "`n   *** Downloading SQL Setup from LAN ***`n" -ForegroundColor Yellow
	
}

task ExtractSql -Description 'Extract SQL Setup' -Action {
	
	Write-Host "`n   *** Extracting SQL Setup files ***`n" -ForegroundColor Yellow
	
}

task InstallSqlDriveC -Description 'Install SQL on C:' -Action {
	
	Write-Host "`n   *** Installing SQL Server on C drive ... please wait... ***`n" -ForegroundColor Yellow

}

task InstallSqlDriveD -Description 'Install SQL on D:' -Action {
	
	Write-Host "`n   *** Installing SQL Server on D drive ... please wait... ***`n" -ForegroundColor Yellow
	
}

Definizione dell’ordine di esecuzione delle attività

Ora hai un file PSake che contiene un insieme di attività. A questo punto, puoi eseguire tutte le attività contemporaneamente o scegliere di eseguirne solo alcune con il comando Invoke-PSake.

È possibile chiamare alcune (o tutte le attività) utilizzando Invoke-PSake e il parametro TaskList come fatto in precedenza nell’esempio semplice. Se hai più di un’attività da invocare, crea un array e definisci il nome di ogni attività come elemento, come mostrato di seguito.

Invoke-PSake eseguirà ogni attività nell’ordine definito nell’array.

$taskList = @()

$taskList += 'ValidateDiskSpace'
$taskList += 'DownloadSql'
$taskList += 'ExtractSql'
$taskList += 'InstallSqlDriveC'
$taskList += 'InstallSqlDriveD'

Invoke-PSake -TaskList $taskList

Quando esegui il codice sopra riportato, dovresti ottenere un risultato simile al seguente:

Aggiunta di una PreCondizione

Forse hai bisogno di eseguire una determinata azione solo se viene soddisfatta una certa condizione. Nell’esempio dello script di installazione di SQL di questo tutorial, ad esempio, potresti dover verificare se il volume in cui archivi l’installatore è disponibile prima di eseguire l’attività per invocare detto installatore.

Puoi utilizzare il parametro PreCondition per eseguire un pezzo di codice che restituisce un valore booleano True o False che determina se l’attività viene eseguita o meno.

Nota nell’esempio seguente le variabili $installSqlOn_C_Drive e $installSqlOn_D_Drive. Quando Invoke-PSake invoca questo script, queste variabili conterranno un valore True o False a seconda che esista un volume C o D.

In ogni riga task, puoi quindi vedere che ogni attività ha un parametro scriptblock PreCondition che contiene il valore di queste variabili. Al momento dell’esecuzione, verrà eseguita l’attività InstallSqlDriveC o InstallSqlDriveD, a seconda di queste variabili.

$installSqlOn_C_Drive = (Test-Path -Path 'C:') -and (-not (Test-Path -Path 'D:'))
$installSqlOn_D_Drive = (-not (Test-Path -Path 'C:')) -and (Test-Path -Path 'D:')

task InstallSqlDriveC -Description 'Install SQL on C:' -PreCondition { $installSqlOn_C_Drive } -Action {
	
	Write-Host "`n   *** Installing SQL Server on C drive ... please wait... ***`n" -ForegroundColor Yellow
	
}

task InstallSqlDriveD -Description 'Install SQL on D:' -PreCondition { $installSqlOn_D_Drive } -Action {
	
	Write-Host "`n   *** Installing SQL Server on D drive ... please wait... ***`n" -ForegroundColor Yellow
	
}

Parametri dell’Attività

Oltre all’Action e alla Description, un task supporta anche questi parametri:

• PreCondition – Blocco di script che restituisce un valore booleano. Se False, il task specifico viene saltato. (Un esempio di utilizzo è mostrato sopra).
• PostCondition – Passo di convalida. Un blocco di script che restituisce un valore booleano. False significa che la convalida non è riuscita e interrompe l’esecuzione dello script.
• PreAction – Un blocco di script da eseguire prima del task.
• PostAction – Un blocco di script da eseguire subito dopo il completamento del task con successo.
• ContinueOnError – Parametro di commutazione. Se utilizzato, eventuali errori che possono verificarsi durante l’esecuzione del task non interromperanno l’intero script.
• Depends – Il nome di un task (o una lista di nomi di task) che deve essere eseguito prima del task corrente. PSake utilizzerà queste informazioni per eseguire le dipendenze dei task nell’ordine corretto. Ad esempio, se il task A dipende dal task B, allora il motore PSake eseguirà B prima di A.

All’inizio il meccanismo di dipendenza sembra una buona idea. Aiuta a impostare i task in un ordine logico. Tuttavia, l’utilizzo del parametro Depends lega insieme diversi task, rendendo successivamente difficile testarli in modo indipendente. Ma poiché l’utente può impostare esplicitamente l’ordine di esecuzione dei task e passare questo ordine quando chiama il file PSake → l’uso del parametro Depends può essere evitato del tutto.

Vediamo di seguito un esempio di utilizzo di alcuni di questi parametri del task:

Aggiunta di PreAction e PostCondition

Utilizzando il compito InstallSqlDriveD dall’esempio sopra come punto di partenza, forse hai una richiesta aggiuntiva per l’installazione.

Forse hai bisogno di registrare i tempi in cui inizia e finisce l’installazione. Devi registrare questi tempi in due variabili di ambiente chiamate SqlSetupStartDate e SqlSetupEndDate. In secondo luogo, dopo che l’installazione è completata, devi verificare che la cartella D:\TempSqlFiles non esista.

Fortunatamente, i parametri del compito PSake PreAction, PostAction e PostCondition (rispettivamente) soddisfano esattamente queste nuove richieste. Di seguito è riportato un esempio di come può essere fatto:

task InstallSqlDriveD -Description 'Install SQL on D:' -PreAction {

     Write-Host '*** Writing SQL install start time to env. var. SqlSetupStartDate ***' -ForegroundColor Yellow
     $date = Get-Date -Format 'yyyy-MM-dd HH:mm:ss'
[Environment]::SetEnvironmentVariable('SqlSetupStartDate',$date,'Machine')

 } -PreCondition { 

     $installSqlOn_D_Drive

 } -Action {  
  
     Write-Host '*** Installing SQL Server on D drive... please wait... ***' -ForegroundColor Yellow 

} -PostAction {     

    Write-Host '*** Writing SQL install end time to env. var. SqlSetupEndDate ***' -ForegroundColor Yellow     
    $date = Get-Date -Format 'yyyy-MM-dd HH:mm:ss'
[Environment]::SetEnvironmentVariable('SqlSetupEndDate',$date,'Machine') 

} -PostCondition { 
    
Write-Host '*** Verifying temp files deleted ***' -ForegroundColor Yellow
     # nel caso in cui la cartella esista, questo restituirà False, causando l'interruzione dell'intero script
     (-not (Test-Path -Path 'D:\TempSqlFiles'))

 }

Esecuzione di script PSake in test Pester

Ovunque sia possibile richiamare uno script PowerShell, è possibile richiamare un file PSake. Se stai creando test di infrastruttura con Pester, puoi richiamare PSake all’interno dei test.

Correlato: Scrittura di test Pester per PowerShell

Ad esempio, forse hai un test Pester per confermare che il file ZIP di configurazione di SQL esista in una cartella dopo aver eseguito il compito DownloadSql. In tal caso, costruisci un semplice test Pester e richiami il compito DownloadSql all’interno del test e controlli la presenza del file ZIP subito dopo la sua esecuzione.

Describe 'SQL install with PSake' {

    It 'Downloads Sql files' {

        $setup = 'C:\Downloads\SqlSetup.zip'

        if(Test-Path -Path $setup)
        {
            Remove-Item -Path $setup
        }

        # l'unico compito sotto test qui è DownloadSql
        Invoke-PSake -BuildFile C:\Work\psakefile.ps1 -TaskList DownloadSql
        
        $setup | Should -Exist
    }
}

Passaggio di parametri alle attività

Una volta iniziato a utilizzare PSake potresti voler parametrizzare alcune delle attività. Tipicamente, con le funzioni e gli script di PowerShell, passerai vari parametri con nome alla funzione/script; PSake è diverso.

Per passare i parametri ai file PSake, puoi utilizzare un blocco Proprietà che definisce coppie chiave/valore che PSake rende disponibili all’interno di ogni attività nel file.

Assicurati di definire il blocco Proprietà all’inizio del file PSake. Tutte le operazioni di PSake vengono lette dall’alto verso il basso.

Ad esempio, per passare le variabili dinamiche SqlYear e SqlVersion a ogni attività nel file PSake, puoi definirle come mostrato di seguito.

Properties {
    $SqlYear = '2017'
    $SqlVersion = '14.0'
}

task -Name DownloadSql -Action {
    
    Write-Host "SQL version to install: SQL $SqlYear (version $SqlVersion)"

}

Quando successivamente invochi il file PSake con Invoke-PSake, vedrai l’output seguente. Nota che le variabili $SqlYear e $SqlVersion sono state espandete con i valori definiti nel blocco Proprietà.

psake version 4.9.1
Copyright (c) 2010-2018 James Kovacs & Contributors

Executing DownloadSql
SQL version to install: SQL 2017 (version 14.0)

psake succeeded executing C:\Work\PSakefile.ps1

--------------------------------------------------
Build Time Report
--------------------------------------------------

Name        Duration
----        --------
DownloadSql 00:00:00
------      --------
Total:      00:00:00

Utilizzando il parametro Proprietà

Se preferisci passare i parametri a un’attività tramite un parametro tradizionale, PSake può aiutarti. Devi comunque mantenere il blocco Proprietà all’inizio del file psakefile.ps1 come nell’esempio precedente, ma PSake ti consente di sovrascrivere i valori.

Per farlo, definisci una hashtable con ciascuna delle coppie chiave/valore che desideri sovrascrivere. Quindi, passa la hashtable al parametro Properties. L’engine PSake utilizzerà i valori della hashtable passata sopra quelli specificati nel blocco Properties all’interno dello script psakefile.ps1.

Nota le differenze di sintassi tra il blocco Properties e il parametro Properties. Nel blocco Properties ogni riga è una variabile e quindi viene preceduta da un simbolo del dollaro, mentre il parametro Properties è una hashtable, quindi ogni elemento è una chiave e scritta senza un simbolo del dollaro iniziale. Un’altra differenza è che la hashtable è preceduta dal carattere @.

Di seguito puoi vedere un esempio di utilizzo del parametro Properties.

$myNewProperties = @{
    SqlYear = '2019'
    SqlVersion = '15.0'
}

Invoke-PSake -TaskList DownloadSql -Properties $myNewProperties

Modularizzazione delle attività PSake: Attività come file

Ad un certo punto, il tuo file PSake probabilmente crescerà in modo esponenziale, specialmente se hai bisogno di orchestrare grandi attività di automazione. Per assicurarti di poter gestire tutte quelle attività, dovresti concentrarti sulla modularizzazione o sulla suddivisione delle attività per semplificare la gestione.

Correlato: Come sopravvivere alla rifattorizzazione di uno script PowerShell dall’inferno

Nell’esempio di questo tutorial, stavi lavorando con cinque attività:

• ValidateDiskSpace
• DownloadSql
• ExtractSql
• InstallSqlDriveC
• InstallSqlDriveD

Ogni singolo compito è definito all’interno di uno script pssakefile.ps1. Se prevedi di aggiungere molti altri compiti nel tempo, dovresti suddividerli in file separati, con ogni compito all’interno ad esempio di ValidateDiskSpace.ps1, DownloadSql.ps1, InstallSqlDriveD.ps1, InstallSqlDriveD.ps1, ecc.

Ad esempio, InstallSqlDriveD.ps1 conterrà solo questo codice:

task InstallSqlDriveD -Description 'Install SQL on D:' -PreCondition { $installSqlOn_D_Drive } -Action {
	
	Write-Host "`n   *** Installing SQL Server on D drive ... please wait... ***`n" -ForegroundColor Yellow
	
}

Una volta spostati i compiti, importa i file nel psakefile.ps1 utilizzando la funzione Include. Una volta fatto ciò, il contenuto di psakefile.ps1 si ridurrà a questo codice:

$installSqlOn_C_Drive = $true
$installSqlOn_D_Drive = $false

Include "$PSScriptRoot\ValidateDiskSpace.ps1"
Include "$PSScriptRoot\DownloadSql.ps1"
Include "$PSScriptRoot\ExtractSql.ps1"
Include "$PSScriptRoot\InstallSqlOnC.ps1"
Include "$PSScriptRoot\InstallSqlOnD.ps1"

Quando Invoke-PSake attiva lo script psakefile.ps1, Invoke-PSake non sa né si preoccupa se i compiti sono presenti nel file psake o sono stati importati tramite il metodo Include.

Passaggi successivi

PSake è un potente orchestratore di script che può essere utilizzato per molti scopi: creazione di software, CI/CD, distribuzione di pacchetti, creazione di installatori e altro ancora. L’unico limite è la tua immaginazione. Abituarsi a costruire script complessi con PSake ti costringe a pensare in termini di compiti (blocchi di codice). Il concetto di compiti sfrutta la sintassi di PowerShell e, utilizzando i compiti, arricchisci le tue conoscenze della riga di comando esistente.

Il codice che produci con PSake diventa più leggibile, manutenibile e più facile da testare. Dopo un po’ di pratica, scoprirai che dividere i passaggi in diversi compiti li rende più facili da scrivere. La piccola quantità di lavoro extra che richiede si ripaga nel medio e lungo termine.

Dove pensi che PSake possa essere utile nei tuoi progetti lavorativi?