Automatisation des tâches avec PowerShell PSake : Guide pas à pas

Vous avez donc appris à automatiser des tâches avec un script PowerShell. C’est génial ! Mais maintenant, vous vous retrouvez avec un désordre de scripts et de modules, avec un mélange d’exécutions de scripts manuelles, de tâches planifiées, et bien plus encore. Il est temps de mettre de l’ordre dans ce chaos et de mettre en place le moteur d’orchestration d’automatisation connu sous le nom de PowerShell PSake.

PSake est un moteur d’orchestration écrit en tant que module PowerShell qui apporte de l’ordre à vos scripts et vous donne un contrôle total sur ce qui s’exécute quand et dans quelles conditions. Bien que PSake soit un outil d’automatisation de build et qu’il soit principalement utilisé dans des scripts de build (généralement exécutés par un serveur de build dans des scénarios d’automatisation de mise en production), il est généralement négligé dans les scénarios de scripting quotidiens. Changeons cela.

Dans ce tutoriel, vous allez apprendre comment PSake fonctionne, avec de bons exemples à mettre en pratique dès aujourd’hui !

Prérequis

Cet article sera un tutoriel, nous supposons que vous allez suivre étape par étape. Si vous souhaitez suivre exactement les instructions, assurez-vous de disposer de :

• Windows PowerShell 3+. Le tutoriel utilise Windows PowerShell v5.1
• Le fichier zip PSake de Github. Ce tutoriel utilise la version 4.9.0.

Configuration du module PSake

En supposant que vous avez le projet PSake de GitHub sur votre machine locale, vous devrez d’abord suivre quelques étapes pour le configurer.

1. Extrayez le fichier zip PSake téléchargé depuis GitHub.
2. Déplacez le dossier src à l’intérieur du contenu du fichier ZIP extrait vers un chemin sous $env:PSModulePath pour vous assurer que PowerShell connaît le nouveau module.
3. Renommez le dossier src en PSake.
4. Exécutez maintenant Get-Module PSake -ListAvailable pour confirmer qu’il apparaît. Si vous ne recevez pas d’erreur, vous êtes prêt à continuer.

Lié : Comprendre et construire des modules PowerShell

Création d’un script de base PowerShell PSake

Pour comprendre PSake, vous devez construire quelque chose. Construisons un script PSake simple pour voir ce qu’il peut faire.

1. Créez un script nommé psakefile.ps1 avec une seule tâche. Au minimum, une tâche doit avoir un nom et un bloc d’action. Le nom psakefile.ps1 n’est pas obligatoire, mais c’est le nom par défaut attendu par le moteur.

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.

Voici un exemple d’un psakefile.ps1 avec une tâche assez simple:

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

2. Maintenant que vous avez construit le fichier PSake, vous pouvez l’appeler à partir d’une console PowerShell avec la commande Invoke-PSake et transmettre le nom de la tâche en tant que valeur au paramètre TaskList .

Invoke-PSake est le moteur d’exécution de PSake. Cette commande déclenche les tâches définies dans psakefile.ps1. Vous pouvez passer un nom de tâche ou une liste de tâches séparées par des virgules au paramètre TaskList. Si vous exécutez plusieurs tâches, chaque tâche s’exécutera dans l’ordre dans lequel vous les avez passées à TaskList, indépendamment de leur emplacement dans psakefile.ps1.

Voici comment vous pouvez déclencher la tâche HelloWorld:

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

Tant que vous conservez le nom psakefile.ps1 et que vous définissez la console sur le dossier où il se trouve, vous pouvez omettre le paramètre BuildFile et sa valeur.

3. En exécutant Invoke-PSake , vous verrez la sortie de PSake dans la console. Lorsque vous exécutez les tâches dans psakefile.ps1, vous verrez une sortie similaire à celle ci-dessous.

La sortie se compose des éléments suivants:

1. Les détails sur la version de PSake.
2. Le nom de chaque tâche de construction juste avant son exécution (PSake considère chaque tâche comme une tâche de construction). Dans l’exemple : Exécution de HelloWorld en cyan.
3. Toute sortie générée par la tâche. Dans l’exemple : Hello World en jaune.
4. Message de succès/échec. Dans l’exemple : psake a réussi… en vert.
5. Résumé du temps (appelé Rapport de temps de construction) avec la durée de chaque tâche, ainsi que la durée totale du script.

Installation de SQL avec PSake

Dans la section précédente, vous n’avez pas fait grand-chose, mais vous avez invoqué un script PSake factice. Maintenant, construisez là-dessus et créez un script PSake qui installe SQL !

Dans cet exemple, vous allez créer un script PSake qui :

1. Vérifie l’espace disque libre sur une machine.
2. Télécharge un fichier ZIP SQL à partir d’un référentiel local.
3. Extrait le fichier ZIP.
4. Exécute l’installation sur le lecteur C ou D (celui des deux qui existe).

Voyons maintenant comment nous pouvons utiliser PSake pour accomplir cette tâche.

Conception des blocs de construction

PSake consiste à orchestrer des tâches. Chaque tâche doit avoir un nom unique et idéalement effectuer une opération atomique unique, comme une fonction PowerShell. En utilisant ce concept, vous pouvez décrire les étapes ci-dessous pour créer une tâche pour chacune.

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

À ce stade, vous ne construisez pas réellement le code pour accomplir quoi que ce soit ; vous créez simplement l’infrastructure des tâches et créez le fichier PSake. Vous remarquerez les références Write-Host dans les tâches ci-dessous ; vous ajouterez du code aux tâches plus tard.

Vous devriez toujours utiliser le paramètre Description pour chaque tâche. Le paramètre Description fournit plus d’informations sur chaque tâche lors de l’exécution des tâches et lors de l’examen du code.

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
	
}

Définition de l’ordre d’exécution des tâches

Vous disposez maintenant d’un fichier PSake qui contient un ensemble de tâches. À ce stade, vous pouvez exécuter toutes les tâches à la fois ou choisir d’en exécuter uniquement certaines avec la commande Invoke-PSake.

Vous pouvez appeler certaines (ou toutes les tâches) en utilisant Invoke-PSake et le paramètre TaskList comme vous l’avez fait précédemment dans l’exemple simple. Si vous avez plus d’une tâche à appeler, créez un tableau et définissez le nom de chaque tâche comme un élément, comme indiqué ci-dessous.

Invoke-PSake exécutera chaque tâche dans l’ordre défini dans le tableau.

$taskList = @()

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

Invoke-PSake -TaskList $taskList

Lorsque vous exécutez le code ci-dessus, vous devriez obtenir un résultat comme celui-ci :

Ajout d’une condition préalable

Il se peut que vous ayez besoin d’effectuer une action seulement si une certaine condition est remplie. Dans l’exemple de script d’installation de SQL de ce tutoriel, par exemple, vous devez peut-être tester si le volume où vous stockez l’installateur est disponible avant d’exécuter la tâche pour invoquer ledit installateur.

Vous pouvez utiliser le paramètre PreCondition pour exécuter un morceau de code qui renvoie soit un True ou un False booléen qui dicte si cette tâche s’exécute ou non.

Remarquez dans l’exemple ci-dessous les variables $installSqlOn_C_Drive et $installSqlOn_D_Drive. Lorsque Invoke-PSake invoque ce script, ces variables contiendront une valeur True ou False en fonction de l’existence d’un volume C ou D.

Sur chaque ligne de task, vous pouvez voir que chaque tâche a un paramètre de scriptblock PreCondition qui contient la valeur de ces variables. Au moment de l’exécution, soit la tâche InstallSqlDriveC soit la tâche InstallSqlDriveD s’exécutera, en fonction de ces variables.

$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
	
}

Paramètres de tâche

En plus des Action et Description, une tâche prend également en charge ces paramètres :

• PreCondition – Bloc de script renvoyant une valeur booléenne. Si False, la tâche spécifique est ignorée. (Un exemple d’utilisation est montré ci-dessus).
• PostCondition – Étape de validation. Un bloc de script renvoyant une valeur booléenne. False signifie que la validation a échoué et entraîne l’arrêt complet du script.
• PreAction – Un bloc de script à exécuter avant la tâche.
• PostAction – Un bloc de script à exécuter immédiatement après la fin réussie de la tâche.
• ContinueOnError – Paramètre de commutation. S’il est utilisé, toutes les erreurs pouvant survenir pendant l’exécution de la tâche ne provoqueront pas l’arrêt complet du script.
• Depends – Nom d’une tâche (ou une liste de noms de tâches) qui doit être exécutée avant l’exécution de la tâche actuelle. PSake utilisera cette information pour exécuter les dépendances de tâches dans le bon ordre. Par exemple, si la tâche A dépend de la tâche B, le moteur PSake exécutera B avant A.

Dans un premier temps, le mécanisme de dépendance semble être une bonne idée. Il permet de définir les tâches dans un ordre logique. Cependant, l’utilisation du paramètre Depends lie différentes tâches ensemble, ce qui rend ensuite difficile leur test indépendant. Mais, puisque l’utilisateur peut définir explicitement l’ordre d’exécution des tâches et passer cet ordre lors de l’appel du fichier PSake, l’utilisation du paramètre Depends peut être évitée complètement.

Voyons maintenant un exemple d’utilisation de certains de ces paramètres de tâche :

Ajout de PreAction et PostCondition

En utilisant la tâche InstallSqlDriveD de l’exemple ci-dessus comme point de départ, peut-être avez-vous une demande supplémentaire pour l’installation.

Peut-être avez-vous besoin d’enregistrer les heures de début et de fin de l’installation. Vous devez enregistrer ces heures dans deux variables d’environnement nommées SqlSetupStartDate et SqlSetupEndDate. Deuxièmement, après la fin de l’installation, vous devez vérifier que le dossier D:\TempSqlFiles n’existe pas.

Heureusement, les paramètres de tâche PSake PreAction, PostAction et PostCondition (respectivement) répondent exactement à ces nouvelles exigences. Voici un exemple de comment cela peut être fait :

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
     # dans le cas où le dossier existe, cela renverra False, ce qui arrêtera tout le script
     (-not (Test-Path -Path 'D:\TempSqlFiles'))

 }

Exécution de scripts PSake dans des tests Pester

Où vous pouvez invoquer un script PowerShell, vous pouvez invoquer un fichier PSake. Si vous construisez des tests d’infrastructure avec Pester, vous pouvez invoquer PSake dans les tests.

Relatif : Écriture de tests Pester pour PowerShell

Par exemple, vous avez peut-être un test Pester pour confirmer que le fichier ZIP de configuration de SQL existe dans un dossier après avoir exécuté la tâche DownloadSql. Dans ce cas, vous créez un test Pester simple et invoquez la tâche DownloadSql dans le test et vérifiez la présence du fichier ZIP juste après son exécution.

Describe 'SQL install with PSake' {

    It 'Downloads Sql files' {

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

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

        # la seule tâche testée ici est DownloadSql
        Invoke-PSake -BuildFile C:\Work\psakefile.ps1 -TaskList DownloadSql
        
        $setup | Should -Exist
    }
}

Passage des paramètres aux tâches

Une fois que vous commencez à utiliser PSake, vous voudrez peut-être paramétrer certaines des tâches. Généralement, avec les fonctions et scripts PowerShell, vous passerez différents paramètres nommés à la fonction/script; PSake est différent.

Pour passer des paramètres aux fichiers PSake, vous pouvez utiliser un bloc Properties qui définit des paires clé/valeur que PSake rend ensuite disponibles à l’intérieur de chaque tâche du fichier.

Assurez-vous de définir le bloc Properties en haut du fichier PSake. Toutes les opérations PSake sont lues de haut en bas.

Par exemple, pour passer les variables dynamiques SqlYear et SqlVersion à chaque tâche dans le fichier PSake, vous pouvez les définir comme indiqué ci-dessous.

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

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

}

Lorsque vous invoquez ensuite le fichier PSake avec Invoke-PSake, vous verrez alors la sortie suivante. Remarquez que les variables $SqlYear et $SqlVersion ont été étendues avec les valeurs définies dans le bloc Properties.

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

Utilisation du paramètre Properties

Si vous préférez passer des paramètres à une tâche via un paramètre traditionnel, PSake peut vous aider. Vous devez toujours garder le bloc Properties en haut du psakefile.ps1, comme dans l’exemple ci-dessus, mais PSake vous permet de remplacer les valeurs.

Pour ce faire, définissez une table de hachage avec chacune des paires clé/valeur que vous souhaitez remplacer. Ensuite, passez la table de hachage en tant que paramètre Properties. Le moteur PSake utilisera les valeurs de la table de hachage passée en paramètre plutôt que celles spécifiées dans le bloc Properties du script psakefile.ps1.

Notez les différences de syntaxe entre le bloc Properties et le paramètre Properties. Dans le bloc Properties, chaque ligne est une variable et est donc précédée d’un signe dollar, tandis que le paramètre Properties est une table de hachage, donc chaque élément est une clé et est écrit sans le signe $. Une autre différence est que la table de hachage est précédée du caractère @.

Voici un exemple d’utilisation du paramètre Properties.

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

Invoke-PSake -TaskList DownloadSql -Properties $myNewProperties

Modularisation des tâches PSake : Les tâches en tant que fichiers

À un moment donné, votre fichier PSake va probablement croître de manière exponentielle, surtout si vous devez orchestrer de grandes tâches d’automatisation. Pour vous assurer de pouvoir gérer toutes ces tâches, vous devriez vous concentrer sur la modularisation ou la division des tâches pour faciliter la gestion.

Lié : Comment survivre à la refonte d’un script PowerShell de l’enfer

Dans l’exemple de ce tutoriel, vous avez travaillé avec cinq tâches :

• ValidateDiskSpace
• DownloadSql
• ExtractSql
• InstallSqlDriveC
• InstallSqlDriveD

Chacune de ces tâches est définie à l’intérieur d’un seul script pssakefile.ps1. Si vous prévoyez d’ajouter de nombreuses tâches au fil du temps, vous devriez diviser ces tâches en fichiers séparés, chaque tâche étant incluse dans un fichier différent, par exemple ValidateDiskSpace.ps1, DownloadSql.ps1, InstallSqlDriveD.ps1, InstallSqlDriveD.ps1, etc.

Par exemple, le fichier InstallSqlDriveD.ps1 contiendra uniquement ce code:

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
	
}

Une fois les tâches déplacées, importez les fichiers dans psakefile.ps1 en utilisant la fonction Include. Une fois cela fait, le contenu du fichier psakefile.ps1 est réduit à ce code:

$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"

Lorsque Invoke-PSake déclenche le script psakefile.ps1, Invoke-PSake ne sait pas et ne se soucie pas si les tâches se trouvent dans le fichier psake ou ont été importées par la méthode Include.

Étapes suivantes

PSake est un puissant orchestrateur de scripts qui peut être utilisé à de nombreuses fins : construction de logiciels, CI/CD, déploiement de packages, création d’installateurs, etc. La seule limite est votre imagination. S’habituer à construire de grands scripts avec PSake vous oblige à penser en termes de tâches (blocs de code). Le concept de tâches exploite la syntaxe PowerShell, et en utilisant des tâches, vous enrichissez vos connaissances existantes en ligne de commande.

Le code que vous produisez avec PSake devient plus lisible, plus facile à maintenir et plus facile à tester. Après un peu de pratique, vous constaterez que diviser vos étapes en différentes tâches les rend plus faciles à scripter. Le léger effort supplémentaire nécessaire porte ses fruits à moyen et long terme.

Où voyez-vous la place de PSake dans vos projets professionnels ?