Comment exécuter un script PowerShell

PowerShell est un langage de script et une interface en ligne de commande conçus pour l'automatisation des tâches et la gestion de configuration, principalement utilisés par les administrateurs système et les utilisateurs avancés. Construit sur le framework .NET (.Net Core pour PowerShell 7), il prend en charge Windows, Linux et macOS. Il permet l'automatisation des tâches administratives telles que la gestion des comptes utilisateurs, la configuration des réseaux et la réalisation de sauvegardes, réduisant ainsi les erreurs humaines.

Bien que PowerShell simplifie l'administration, il peut présenter des défis, en particulier pour les débutants. Les problèmes courants incluent des erreurs de syntaxe, des chemins mal configurés, des problèmes de dépendance et des messages d'erreur déroutants. De plus, pour renforcer la sécurité, l'exécution de scripts est restreinte par défaut, obligeant les utilisateurs à ajuster les politiques d'exécution pour exécuter des scripts. Pour maximiser le potentiel de PowerShell tout en maintenant la sécurité, les utilisateurs doivent combiner une manipulation soigneuse des scripts avec des compétences de dépannage.

Pourquoi utiliser des scripts PowerShell ?

Les scripts PowerShell sont un outil essentiel pour les administrateurs système et les développeurs dans les environnements Windows et multiplateformes. Automatiser des processus comme la gestion des comptes, la surveillance du réseau et le déploiement de logiciels permet de gagner un temps considérable, libérant ainsi les professionnels de l'informatique pour se concentrer sur des initiatives stratégiques, l'optimisation des flux de travail et la résolution de problèmes, favorisant une plus grande efficacité et innovation. Ils peuvent même planifier des scripts pour une exécution automatique. PowerShell Remoting amplifie la valeur de PowerShell en permettant une gestion à distance sécurisée de plusieurs systèmes depuis une interface centrale, réduisant le besoin d'accès physique et améliorant les temps de réponse aux incidents.

L'utilisation de scripts PowerShell garantit également une exécution cohérente et précise des opérations complexes. Éliminer l'erreur humaine est essentiel pour maintenir des configurations uniformes comme l'exigent la conformité et la sécurité. Cette fiabilité est inestimable dans les environnements à grande échelle où même de petites incohérences peuvent conduire à des vulnérabilités ou à des défaillances opérationnelles.

Comprendre les politiques d'exécution PowerShell

PowerShell utilise des politiques d'exécution pour contrôler si les scripts PowerShell peuvent s'exécuter sur un système et, si oui, dans quelles conditions.

Paramètres de stratégie d'exécution

Les stratégies d'exécution peuvent avoir les paramètres suivants :

• Restreint: Aucun script ne peut être exécuté ; seules les commandes individuelles peuvent être exécutées dans l'invite de commande PowerShell. Tenter d'exécuter un script entraîne le message d'erreur : « L'exécution de scripts est désactivée sur ce système. » C'est le paramètre par défaut pour la plupart des systèmes.
• AllSigned : Seuls les scripts signés par un éditeur de confiance peuvent être exécutés. Ce paramètre offre un haut degré de sécurité car il garantit que seuls les scripts vérifiés sont exécutés.
• RemoteSigned : Les scripts créés localement peuvent s'exécuter sans signature, mais les scripts téléchargés depuis Internet doivent être signés par un éditeur de confiance. Cette politique est souvent recommandée pour une utilisation routinière.
• Sans restriction : Tous les scripts peuvent être exécutés, quelle que soit leur origine ou s'ils sont signés. Cependant, les utilisateurs recevront un avertissement lors de l'exécution de scripts téléchargés pour les alerter des risques.

Comment changer une politique d'exécution en utilisant Set-ExecutionPolicy

Pour modifier une politique d'exécution, utilisez le cmdlet Set-ExecutionPolicy. Le paramètre -Scope définit la portée : CurrentUser s'applique uniquement à l'utilisateur actuellement connecté, tandis que LocalMachine s'applique à tous les utilisateurs du système (l'utilisation de cette valeur nécessite des droits d'administrateur).

Voici un exemple :

      Set-ExecutionPolicy RemoteSigned -Scope CurrentUser
      

Confirmez le changement en tapant Y (Oui) lorsque cela est demandé.

Vérification de la politique d'exécution à l'aide de Get-ExecutionPolicy

Vous pouvez vérifier la politique d'exécution actuelle avec la commande suivante :

      Get-ExecutionPolicy -List
      

Voici un exemple de sortie :

Guide étape par étape pour exécuter des scripts PowerShell

Pour exécuter un script PowerShell à partir de PowerShell, suivez ces étapes :

Étape 1 : Lancez PowerShell

Avant d'exécuter un script, vous devez ouvrir PowerShell. Voici deux options :

• Cliquez sur le menu Démarrer, tapez PowerShell et sélectionnez Windows PowerShell.

• Lancez l'invite de commande en tapant cmd dans le menu Démarrer. Tapez powershell pour ouvrir une session PowerShell.

Étape 2 : Naviguez jusqu'à l'emplacement du script

Ensuite, naviguez vers le répertoire où le fichier .ps1 est stocké en exécutant la commande cd :

      cd C:\Users\AbbeyCrawford\Scripts
      

Étape 3 : Exécutez le script

La commande pour exécuter un script PowerShell dépend si vous êtes dans le répertoire où votre script est situé :

• Si vous êtes dans le répertoire où se trouve votre script, voici comment exécuter un script dans PowerShell :

      .\HelloWorld.ps1
      

• Si vous n'êtes pas dans le répertoire du script, pour exécuter un script PowerShell, vous devez fournir son chemin complet :

      C:\Users\JohnDoe\Scripts\HelloWorld.ps1
      

• Si le script se trouve dans un sous-dossier du répertoire actuel, utilisez le préfixe .\ pour fournir le chemin relatif :

      .\SubFolder\HelloWorld.ps1
      

• Un point (.) avant le chemin indique que vous souhaitez exécuter le script dans la session actuelle pour permettre à ses variables ou fonctions de rester disponibles après l'exécution. (L'approvisionnement par point est expliqué plus en détail plus loin dans ce document.) Notez l'espace entre les deux points.

      . .\HellowWorld.ps1
      

      . C:\Scripts\MyScripts\HelloWorld.ps1
      

Exécution de scripts avec des paramètres

De nombreux scripts PowerShell acceptent des paramètres pour les rendre plus flexibles. Vous pouvez passer des arguments lors de l'exécution du script.

Par exemple, supposons que vous avez le script suivant qui accepte deux paramètres, Name et Age :

      param(

    [string]$Name,

    [int]$Age

)

Write-Host "Hello, $Name! You are $Age years old."

When running the script, you can pass arguments to it as follows:

.\Get-UserInfo.ps1 -Name "John" -Age 30
      

Comment exécuter un script PowerShell depuis CMD

Pour exécuter un script PowerShell depuis l'invite de commande, suivez les étapes suivantes :

1. Ouvrez l'invite de commande en tapant cmd dans la barre de recherche et en appuyant sur Entrée.
2. Utilisez la commande suivante pour exécuter votre script PowerShell. L'option -File est requise ; elle spécifie le fichier de script à exécuter.

      powershell -File C:\Scripts\Get-UserInfo.ps1
      

Utilisation de l'option -NoExit Option

Dans certains cas, vous pourriez souhaiter que la fenêtre PowerShell reste ouverte après l'exécution de votre script. Cela peut être particulièrement utile pour le débogage ou lorsque le script est conçu pour afficher des résultats que vous souhaitez voir avant que la fenêtre ne se ferme.

Pour garder la fenêtre PowerShell ouverte lors de l'exécution de scripts depuis l'invite de commande, utilisez l'option -NoExit comme indiqué ci-dessous :

      powershell -NoExit -File C:\Scripts\Backup.ps1
      

Comment exécuter PowerShell en tant qu'administrateur

De nombreuses tâches administratives nécessitent des autorisations élevées pour être exécutées avec succès. Les exemples incluent l'installation de logiciels, la modification des paramètres réseau et l'accès aux répertoires système. Tenter d'effectuer ces tâches sans droits administratifs peut entraîner des erreurs, susceptibles de bloquer des tâches importantes de maintenance ou de configuration.

Pour exécuter PowerShell avec des privilèges administratifs, faites un clic droit sur Windows PowerShell et choisissez Exécuter en tant qu'administrateur.

Utilisation de Start-Process pour l'exécution administrative

Dans certaines situations, vous devez exécuter une autre instance de PowerShell ou un script depuis une session PowerShell. La cmdlet Start-Process est un outil parfait. Ajouter le paramètre -Verb RunAs indique à PowerShell de lancer une nouvelle instance avec des droits administratifs :

      Start-Process PowerShell -Verb RunAs
      

Pour exécuter un script spécifique avec des privilèges élevés, ajoutez le paramètre -ArgumentList et utilisez -File pour spécifier le chemin du script. Voici deux exemples :

      Start-Process PowerShell -ArgumentList '-File "C:\Scripts\Update-Software.ps1"' -Verb RunAs
      

      Start-Process powershell -ArgumentList "-NoProfile -ExecutionPolicy Bypass -File “ C:\Scripts\Update-Software.ps1” -Verb RunAs
      

Erreurs courantes et comment les corriger

Résoudre des erreurs peut sembler intimidant au début, mais les résoudre est une étape importante, comparable à l'obtention de badges d'or, d'argent et de bronze pour les compétences de débogage. Voici quelques-uns des problèmes les plus courants et comment les résoudre efficacement.

Erreur « L'exécution de scripts est désactivée »

Cette erreur se produit parce que la politique d'exécution par défaut de PowerShell est définie sur Restricted, ce qui empêche l'exécution de tous les scripts. Par exemple, la capture d'écran ci-dessous montre l'erreur, « Le fichier C:\Scripts\Get-UserInfo.ps1 ne peut pas être chargé car l'exécution de scripts est désactivée sur ce système » :

Pour résoudre ce problème, modifiez la politique d'exécution pour autoriser l'exécution de scripts. Utilisez Set-ExecutionPolicy pour passer à un paramètre moins restrictif, tel que RemoteSigned.

Erreurs de syntaxe

Les erreurs de syntaxe surviennent généralement à cause d'une structure de commande incorrecte, de paramètres manquants ou de fautes de frappe. Voici un exemple :

Pour corriger les erreurs de syntaxe, lisez attentivement les messages d'erreur affichés et vérifiez le numéro de ligne indiqué pour identifier où l'erreur s'est produite. Pour prévenir les erreurs, vérifiez toujours votre script à la recherche d'erreurs courantes et envisagez d'utiliser un éditeur de code qui offre des fonctionnalités de mise en évidence de la syntaxe ou IntelliSense.

Erreurs de permissions

Les erreurs de permissions surviennent lorsque le script tente d'accéder à des ressources nécessitant des privilèges élevés ou lorsque les permissions de fichier/dossier sont insuffisantes. Par exemple, l'erreur ci-dessous indique que l'accès au chemin C:\Backup\Backup.txt a été refusé :

Voici deux manières de résoudre le problème :

• Cliquez-droit PowerShell, sélectionnez Exécuter en tant qu'administrateur et exécutez votre script à nouveau.
• Vérifiez les permissions du fichier ou du dossier auquel le script accède et accordez les permissions nécessaires à l'aide des cmdlets Get-Acl et Set-Acl.

Exécution de scripts PowerShell dans différents environnements

Le processus d'exécution des scripts PowerShell diffère selon que vous les exécutez :

• Dans l'environnement de script intégré PowerShell (ISE)
• Via l'Explorateur de fichiers
• Utilisation à distance de commandes telles que Invoke-Command

Exécution de scripts dans l'ISE PowerShell

L'ISE de PowerShell est un environnement de développement convivial conçu pour écrire, tester et déboguer des scripts PowerShell. Il offre une interface à plusieurs volets avec des fonctionnalités telles que la mise en évidence de la syntaxe et des outils de débogage intégrés. Pour exécuter des scripts dans l'ISE de PowerShell, suivez ces étapes :

1. Ouvrez l'ISE de PowerShell. Pour le localiser, vous pouvez soit rechercher PowerShell ISE dans le menu Démarrer, soit taper powershell_ise dans la boîte de dialogue Run (Windows + R). Voici l'interface résultante :

• Utilisez le volet de script (fenêtre supérieure) pour écrire ou charger des scripts. Pour créer un nouveau fichier .ps1, appuyez sur FichierèNouveau. Pour enregistrer votre script, cliquez sur Fichier > Enregistrer sous.
• Pour exécuter votre script complet, cliquez sur le bouton Run Script (triangle vert) ou appuyez sur F5. Pour exécuter des lignes sélectionnées, mettez-les en surbrillance et appuyez sur F8.

Exécution de scripts à partir de l'Explorateur de fichiers

Une autre méthode pratique pour exécuter des scripts PowerShell est directement depuis l'Explorateur de fichiers. Cette approche est avantageuse lorsque vous souhaitez exécuter un script sans avoir besoin d'ouvrir une fenêtre de terminal ou pour un accès rapide.

1. Accédez au dossier contenant votre script PowerShell.
2. Cliquez avec le bouton droit sur le fichier de script .ps1. Dans le menu contextuel, sélectionnez Exécuter avec PowerShell. Cela lancera le script dans une nouvelle fenêtre PowerShell et l'exécutera immédiatement.

Exécution de scripts à distance

PowerShell offre également la possibilité d'exécuter des scripts sur des machines distantes sans nécessiter d'accès physique. Cela est particulièrement utile dans les environnements d'entreprise où les tâches doivent être exécutées sur plusieurs serveurs.

Prérequis : Activer l'exécution à distance

Avant de pouvoir exécuter un script à distance, vous devez activer PowerShell Remoting sur le système cible. Exécutez la commande suivante :

      Enable-PSRemoting -Force
      

Syntaxe de base pour Invoke-Command

Invoke-Command vous permet d'exécuter des cmdlets ou des scripts sur des ordinateurs distants. Par exemple, pour exécuter UpdateSystem.ps1 sur un ordinateur distant nommé Server01, utilisez la cmdlet suivante :

      Invoke-Command -ComputerName Server01 -FilePath C:\Scripts\UpdateSystem.ps1
      

Fournir un bloc de script à exécuter

Pour exécuter un bloc de script directement, utilisez cette syntaxe :

      Invoke-Command -ComputerName Server01 -ScriptBlock { Get-Process }
      

Exécution de commandes sur plusieurs ordinateurs

Pour exécuter des scripts sur plusieurs ordinateurs, vous pouvez spécifier les noms des ordinateurs en utilisant une variable, comme indiqué ci-dessous :

      $computers = "PC1", "PC2", "PC3"

Invoke-Command -ComputerName $computers -ScriptBlock { Your PowerShell Commands }
      

Alternativement, vous pouvez passer les noms d'ordinateurs sous forme de liste séparée par des virgules :

      Invoke-Command -ComputerName Server01, Server02 -ScriptBlock { Restart-Service -Name Spooler }
      

Automatisation des scripts PowerShell avec le Planificateur de tâches

Le Planificateur de tâches Windows, un outil intégré au système d'exploitation Windows, permet aux utilisateurs de programmer des tâches pour qu'elles s'exécutent à une date et une heure spécifiques, selon un calendrier défini ou lorsqu'elles sont déclenchées par certains événements.

Pour en savoir plus sur les avantages de la planification de scripts PowerShell et obtenir des instructions détaillées, des exemples, des meilleures pratiques et des conseils de dépannage, veuillez consulter cet article : Comment automatiser des scripts PowerShell avec le Planificateur de tâches.

Techniques avancées

PowerShell offre des techniques avancées pour améliorer la réutilisabilité des scripts, leur modularité, et le partage de variables et de fonctions à travers les scripts. Deux concepts clés sont le dot sourcing et les modules de script.

Dot Sourcing

Normalement, chaque script s'exécute dans une nouvelle session, et toutes les variables ou fonctions déclarées à l'intérieur sont perdues lorsque le script se termine. Avec le dot sourcing, un script est exécuté dans le contexte actuel de sorte que toutes les variables, fonctions ou alias définis dans ce script soient disponibles dans la session qui l'a appelé. Cela est particulièrement utile lorsque vous souhaitez partager des fonctions ou des variables communes entre les scripts ou au sein de la même session.

La syntaxe est la suivante :

      . .\ScriptName.ps1
      

Le premier point suivi d'un espace (. ) indique à PowerShell que vous êtes en train de dot sourcer le script.

La deuxième partie (.\ScriptName.ps1) est le chemin relatif vers votre script.

Utilisation des modules de script

Un module dans PowerShell est un paquet qui contient des fonctions PowerShell, des cmdlets, des variables et plus encore. Les modules sont conçus pour être importés et utilisés dans plusieurs scripts. Comparés au dot sourcing, les modules offrent une meilleure encapsulation et gestion des versions, ce qui facilite l'organisation, la maintenance et le partage de scripts réutilisables.

Pour créer un module de script, enregistrez simplement votre script avec une extension de fichier .psm1 au lieu de .ps1.

Une fois que vous avez créé un module, vous pouvez rendre ses fonctions disponibles dans votre session PowerShell en utilisant l'Import-Module comme suit :

      Import-Module C:\Scripts\Modules\Geometry.psm1
      

Meilleures pratiques pour exécuter des scripts PowerShell

Les meilleures pratiques suivantes sont essentielles pour maintenir la sécurité lors de l'exécution de scripts PowerShell, ainsi que pour améliorer l'utilisabilité et la précision des scripts.

Meilleures pratiques de sécurité

Utilisez des paramètres de stratégie d'exécution forts

Utilisez les stratégies d'exécution de PowerShell pour autoriser uniquement les scripts provenant de sources fiables et vérifiées. Définissez la stratégie d'exécution à un niveau approprié pour votre environnement. Pour la plupart des organisations, RemoteSigned offre un bon équilibre, permettant l'exécution des scripts créés localement tout en exigeant que les scripts téléchargés soient signés par un éditeur de confiance.

Signez numériquement vos scripts

PowerShell vérifie la signature numérique d'un script avant de l'exécuter. Signer numériquement vos scripts avec un certificat de confiance aide à protéger contre les altérations.

Exécutez des scripts avec les moindres privilèges requis

Dans la mesure du possible, exécutez les scripts avec le moindre privilège pour limiter les dommages potentiels en cas de vulnérabilités de sécurité ou d'erreurs.

Bonnes pratiques de documentation

Les scripts bien documentés sont plus faciles à maintenir, déboguer et comprendre pour les utilisateurs actuels et futurs.

Utilisez les commentaires

Les commentaires sont importants pour expliquer le but du script, les paramètres et la logique. Dans PowerShell, les commentaires sont précédés du symbole #.

Pour des explications rapides, utilisez des commentaires en ligne :

      $backupDirectory = "D:\Backup"  # Set the backup directory
      

Pour fournir des explications plus détaillées ou pour désactiver temporairement des parties de votre code, utilisez des commentaires de bloc (<# … #>) :

      <#
      

Ce script effectue une sauvegarde des données critiques.

Il vérifie l'espace disponible et contrôle l'intégrité de la sauvegarde.

      #>
      

Consultez l'Aide

Pour vous assurer que vous utilisez correctement les fonctions PowerShell, utilisez Get-Help pour examiner la syntaxe et l'utilisation des cmdlets. Par exemple, pour obtenir de l'aide sur Get-Process, exécutez la commande suivante :

      Get-Help Get-Process
      

Bonnes pratiques de gestion des erreurs

Une gestion appropriée des erreurs est essentielle pour empêcher les scripts PowerShell de échouer de manière inattendue et de laisser des tâches incomplètes ou des systèmes dans un état instable.

Valider l'entrée

Pour éviter les erreurs inattendues, assurez-vous que vos scripts valident les entrées. Cela est particulièrement important pour les données liées aux utilisateurs comme les noms ou les avatars des utilisateurs.

Implement Try-Catch Blocks

Le bloc try-catch est la méthode principale pour gérer les erreurs dans PowerShell. Cela vous permet d'attraper et de gérer les exceptions de manière élégante. Voici un exemple :

      try {

       # Attempt to run a command

       Copy-Item -Path $source -Destination $destination -Recurse

   } catch {

       # Handle the error

       Write-Host "An error occurred: $_"

       # Additional error recovery actions can be performed here

   }
      

Utilisez Finally Blocks

Ajoutez un bloc final lorsque cela est nécessaire. Ce bloc s'exécutera indépendamment de la survenue d'une erreur dans le bloc try, vous permettant de libérer des ressources ou d'exécuter le code de finalisation. Voici un exemple :

      try {

       # Code that may throw an exception

       Remove-Item -Path $filePath -ErrorAction Stop

   } catch {

       Write-Host "Failed to remove the file: $_"

   } finally {

       Write-Host "Cleanup actions have been performed."

   }
      

Conclusion

PowerShell est un outil extrêmement puissant pour automatiser les tâches d'administration système afin de garantir la précision et améliorer l'efficacité. En comprenant les concepts de base tels que les politiques d'exécution, le dot sourcing et les modules de script, ainsi qu'en suivant les meilleures pratiques pour la sécurité et la gestion des erreurs, vous pouvez tirer pleinement parti de PowerShell pour écrire des scripts robustes, réutilisables et sécurisés qui améliorent vos opérations quotidiennes.

Nous vous encourageons à commencer à expérimenter avec PowerShell en écrivant et exécutant vos propres scripts. Commencez par des tâches d'automatisation simples et plongez progressivement dans des techniques de script avancées. Plus vous pratiquez, plus vous deviendrez compétent dans l'automatisation de flux de travail complexes, la gestion de systèmes à distance et la manipulation d'opérations informatiques à grande échelle.