Exécution de PowerShell depuis cmd. Scripts PowerShell planifiés

Il y a toujours de la place pour la créativité dans l'administration. Voulez-vous effectuer une certaine automatisation d'une tâche de routine? S'il te plait! Avez-vous besoin de vérifier régulièrement l'activité? Pas question! Voulez-vous traiter un rapport gigantesque et afficher uniquement les données actuelles? C'est aussi possible. Toutes ces tâches et bien d'autres sont mieux résolues à l'aide de scripts, et PowerShell dans le cas de Windows est le meilleur choix.

Qu'est-ce que PowerShell et qu'est-ce que c'est bon

Les utilisateurs d'UNIX et de Linux, et à partir d'un moment donné et de macOS, se sont habitués au fait que Bash est toujours à portée de main - un petit outil à l'ancienne, mais universel et puissant avec lequel vous pouvez faire des choses incroyables avec seulement quelques lignes. Vous enregistrez un nouveau script dans cron - et vous avez terminé, il est déjà en cours d'exécution sur votre ordinateur ou serveur et fait tranquillement quelque chose d'utile.

En revenant à Windows (et parfois c'est impossible sans cela), vous vous rendez compte que les scripts .bat sont bons, mais ils ne sauvegardent pas toujours: leurs capacités sont très limitées. Et si vous pensiez toujours que PowerShell est une chose inconnue, pour laquelle vous devez soulever quelque chose et l'installer, alors ne vous précipitez pas vers des conclusions - c'est, si vous regardez, assez bon.

Windows PowerShell est un outil d'automatisation open source extensible qui se compose d'un shell (ligne de commande) et d'un langage de script. Il a été montré pour la première fois en 2003 (il s'appelait alors Monad). PowerShell 2.0 a été publié avec Windows 7 et Windows Server 2008 R2 et est depuis présent présent sous Windows en tant que composant standard. Il a même été inclus dans Windows XP SP3. PowerShell est construit et intégré au .NET Framework. PowerShell peut accéder à COM, WMI et ADSI et, bien sûr, exécute également des commandes de console.

En général, le «posik» a des liens étroits avec les produits Microsoft, qu'il s'agisse d'Active Directory ou d'un serveur de messagerie Exchange. Cela vous permet d'y accéder via la console et d'exécuter des commandes sans vous connecter au composant logiciel enfichable serveur.

Si vous n'étiez pas intéressé par PowerShell auparavant, alors vous avez probablement la deuxième version. Je recommande de mettre à jour au moins le troisième - il contient beaucoup plus de fonctionnalités et de fonctionnalités utiles. Si vous n'entrez pas dans les détails, PowerShell 2.0 comprend environ une douzaine de modules et environ 350 commandes, et PowerShell 3.0 possède déjà environ 2300 applets de commande de plus de 70 modules. Hacker a également écrit sur les différences entre la dernière version 5 de PowerShell de Windows 10.

Choisissez un environnement et des outils de développement

Voyons maintenant où il est le plus pratique d'écrire du code. Vous pouvez, bien sûr, dans le Bloc-notes, Notepad ++ ou Sublime. Mais dans ce cas, ce n'est pas le choix le plus compétent de l'éditeur. Il est préférable de commencer avec PowerShell, armé du pack.

Ce n'est même pas un éditeur, mais un environnement de développement presque complet. Il existe une fonction IntelliSense qui vous permet d'afficher une liste des applets de commande et leurs paramètres, variables, utilitaires, etc. Les extraits sont pris en charge, il est possible d'étendre l'ensemble des fonctions en raison de divers modules complémentaires. Commandes très utiles et fenêtres. Il est possible d'y composer des commandes en mode visuel: vous sélectionnez un module, trouvez l'applet de commande nécessaire et définissez les paramètres nécessaires. La commande résultante peut être copiée sur la console ou exécutée immédiatement. En général, une sorte de constructeur pour l'administrateur. Et bien sûr, il y a la coloration syntaxique, le débogueur et bien plus encore.

Néanmoins, PowerShell ISE a également de dignes concurrents. L'un d'eux l'est.

PowerGUI est un ajout visuel à PowerShell. Il facilite la création de vos propres scripts avant de sélectionner les applets de commande nécessaires. Vous prenez ce dont vous avez besoin pour résoudre le problème et faites glisser et déposez des parties du code jusqu'à ce que vous obteniez le script. L'une des principales caractéristiques de PowerGUI est les Power Packs, des scripts prêts à l'emploi publiés par la communauté des utilisateurs et mis en libre accès. Il existe également des commandes simples comme l'ajout d'utilisateurs et des commandes complexes, par exemple, la gestion des commutateurs et des machines virtuelles. Tous sont faciles à compléter et à modifier selon vos besoins.

Sapien est un environnement plus avancé conçu pour le développement conjoint d'un projet par un grand nombre de participants. Si vous avez déjà traité de Visual Studio, je pense que vous remarquerez une similitude. Les fonctionnalités utiles de PowerShell Studio incluent le panneau du ruban, la prise en charge du débogage à distance et les fonctionnalités du compilateur qui vous permettent d'inclure des scripts dans des fichiers exécutables. Il existe une prise en charge de différentes versions de PowerShell.

Il convient de mentionner le navigateur de scripts pour Windows PowerShell ISE. Ce n'est pas un environnement de développement, mais un outil très intéressant développé par Microsoft. Le Navigateur de scripts donne accès à une base de données de scripts prêts à l'emploi qui peuvent être utilisés comme exemples pour écrire votre code. Et cette chose sait également comment analyser le code que vous écrivez et vous indique comment l'améliorer.

Quelques astuces utiles

Une fois que vous avez compris l'éditeur, vous pouvez commencer à écrire du code. PowerShell est un langage simple, et je pense que vous comprendrez rapidement de quoi il s'agit. Les commandes ici sont appelées applets de commande, et chacune d'entre elles se compose de deux parties. Vient d'abord l'action, par exemple Get, Set, Add, Invoke, Remove. Il indique ensuite à quoi l'action est destinée: Service, VM, AzureAccount, DHCPServerSetting. Chaque partie est séparée de l'autre par un trait d'union. Il s'avère, par exemple, get-process. Soit dit en passant, c'est une commande utile qui répertorie les processus. Dis si tu écris

get - process BadTh *

nous verrons quelque chose comme ceci:

Gère NPM (K) PM (K) WS (K) VM (M) CPU (s) Id ProcessName

------------------------

28 4 - 210844 - 201128 - 163 25,67 2792 BadThread

Vous pouvez maintenant terminer le processus bloqué:

Vous pouvez le voir récursivement, mais avec une logique un peu plus complexe:

Vous pouvez également exécuter

Soit dit en passant, chaque champ de la fenêtre d'options de compte ou d'ordinateur peut être consulté et lire les données. De cette façon, vous pouvez faire des tranches entières. Voici, par exemple, une requête basée sur des données sur les numéros de téléphone:

Get - AdUser - Filter * - Propriétés OfficePhone | FT OfficePhone, UserPrincipalName

PowerShell vs bat

Parfois, une tâche peut être résolue à la fois avec l'ancienne méthode de grand-père et avec l'aide de PowerShell. Je recommande de ne pas être paresseux et d'utiliser PS, ne serait-ce que parce que vous l'apprendrez plus rapidement et pourrez l'utiliser dans des situations plus difficiles. De plus, vous apprécierez progressivement sa syntaxe - plus élégante et cohérente. Voici quelques exemples de la façon dont les choses ont été faites auparavant et comment elles peuvent être effectuées avec PowerShell.

La ligne de commande suivante redémarrera l'ordinateur avec un délai de dix secondes:

Ainsi, grâce à bat, vous pouvez redémarrer le service dnscache (ou tout autre):

sc stop dnscache

sc start dnscache

Exécution d'un programme à partir de PowerShell

La tâche de démarrage de tout fichier exécutable (programme ou utilitaire de ligne de commande) à partir de PowerShell est assez courante. PowerShell propose plusieurs méthodes pour cela, que nous aborderons plus loin dans cet article. Commençons par le plus simple ...

Démarrage direct

La façon la plus simple d'exécuter l'exécutable dans PowerShell est d'aller dans le répertoire contenant le fichier et de le démarrer directement. Par exemple, prenez un programme simple qui affiche un message d'accueil et exécutez-le avec la commande:

Set-Location ″ C: \\ Program Files ″
. \\ Hello.exe

Veuillez noter que même étant dans le bon répertoire, vous devez spécifier le chemin d'accès relatif au fichier exécutable. L'exception concerne les fichiers des répertoires répertoriés dans la variable d'environnement (chemin d'accès). Par exemple, divers micrologiciels et utilitaires (bloc-notes, calcul, ping, etc.) situés dans le répertoire Windows \\ System32 peuvent être lancés sans spécifier de chemin.

Opérateur &

Si vous devez spécifier le chemin d'accès complet au fichier exécutable, vous pouvez utiliser l'opérateur & (appeler l'opérateur). Il vous permet d'exécuter une ligne de texte spécifiée entre guillemets comme une seule commande. Par exemple:

& ′ C: \\ Program Files \\ Hello.exe ′

L'opérateur & n'analysant pas la commande transmise, il ne peut pas interpréter ses paramètres. Par conséquent, des paramètres \\ arguments supplémentaires sont également transmis sous forme de texte, entre guillemets. Par exemple, prenez le programme précédent et modifiez-le un peu, afin qu'il prenne le texte souhaité en argument:

& ′ C: \\ Program Files \\ Hello.exe ′ ′ Bonjour tout le monde ′

Si vous le souhaitez, vous pouvez spécifier plusieurs arguments séparés par des virgules:

& ′ C: \\ Program Files \\ Hello.exe ′ ′ Bonjour, ′, ′ monde ′

Pour plus de commodité, la commande et les arguments peuvent être placés dans des variables:

$ exe \u003d ′ C: \\ Program Files \\ Hello.exe ′
$ arg1 \u003d ′ Bonjour ′
$ arg2 \u003d ′ monde ′
& $ exe $ arg1 $ arg2

Eh bien, s'il y a beaucoup d'arguments, alors ils peuvent être combinés en utilisant cette construction:

$ exe \u003d ′ C: \\ Program Files \\ Hello.exe ′
$ allargs \u003d @ (′ Bonjour, ′, ′ monde ′)
& $ exe $ allargs

Appeler une expression

L'applet de commande Invoke-Expression fonctionne de la même manière que l'opérateur & - elle prend une chaîne de texte et l'exécute comme une commande. Par exemple:

Invoke-Expression -Commande ′ C: \\ Windows \\ Hello.exe ′

Cependant, il présente un gros inconvénient, à savoir l'incapacité de travailler avec les espaces. Par exemple, la commande suivante provoquera une erreur:

Invoke-Expression -Commande ′ C: \\ Program Files \\ Hello.exe ′

Cette fonctionnalité rend l'utilisation de l'applet de commande extrêmement peu pratique. Bien que, si nécessaire, de telles erreurs peuvent être évitées à l'aide de citations supplémentaires, par exemple comme ceci:

Invoke-Expression -Commande ″ C: \\ ′ Program Files ′ \\ Hello.exe ″

Processus de démarrage

L'applet de commande Start-Process exécute le fichier spécifié en tant que processus à l'aide de la méthode Commencer Classe .NET Processus. Par exemple:

Start-Process -FilePath ′ C: \\ Program Files \\ Hello.exe ′

Par défaut, le processus s'exécute dans une fenêtre distincte qui se ferme à la fin du processus. Vous pouvez modifier ce comportement à l'aide des paramètres, de sorte que la commande suivante démarre dans la fenêtre actuelle:

Start-Process -FilePath ′ C: \\ Program Files \\ Hello.exe ′ -NoNewWindow -Wait

Start-Process vous permet également de passer des arguments supplémentaires au processus:

Start-Process -FilePath ′ C: \\ Program Files \\ Hello.exe ′ -ArgumentList ′ Hello, world ′ -NoNewWindow -Wait

Par défaut, la cmdlet ne renvoie rien, mais en utilisant le paramètre -PassThru, vous pouvez la forcer à renvoyer un objet de processus. Cet objet est très pratique pour mettre dans une variable:

$ process \u003d Start-Process -FilePath ′ C: \\ Program Files \\ Hello.exe ′ -Wait -PassThru

à partir de laquelle vous pouvez ensuite apprendre de nombreuses choses utiles, telles que le statut:

$ process.HasExited

$ process.ExitTime

ou code d'exécution:

$ process.ExitCode

.NET

En principe, la classe .NET Process peut être utilisée directement, sans l'applet de commande Start-Process. Par exemple, vous pouvez démarrer le processus avec la commande:

:: Démarrer (′ C: \\ Program Files \\ Hello.exe ′)

Cette méthode est assez peu pratique et encombrante (à mon avis), mais un peu plus souple d'utilisation. Par exemple, exécutez notre programme dans la fenêtre actuelle, passez-lui des arguments et prenez le résultat de l'exécution:

$ process \u003d New-Object -TypeName System.Diagnostics.Process
$ process.StartInfo.FileName \u003d ″ C: \\ Program Files \\ Hello.exe ″
$ process.StartInfo.Arguments \u003d ″ Bonjour tout le monde ″
$ process.StartInfo.RedirectStandardOutput \u003d $ true
$ process.StartInfo.UseShellExecute \u003d $ false
$ process.Start ()
$ process.WaitForExit ()
$ process.StandatdOutput.ReadToEnd ()

Wmi

En utilisant WMI, vous pouvez faire presque tout, y compris exécuter le programme. La méthode est tout à fait appropriée pour cela. Créer Classe WMI Win32_Process.Cette méthode démarre le processus sur un ordinateur local ou distant via RPC. Par exemple, pour exécuter le programme sur l'ordinateur local, vous pouvez utiliser la commande suivante:

() ″ Win32_Process ″). Créez (′ C: \\ Program Files \\ Hello.exe ′)

Et pour une exécution sur un ordinateur distant, la commande ressemblera à ceci:

() ″ \\\\ remotecomputer \\ root \\ cimv2: Win32_Process ″). Créez (′ C: \\ Program Files \\ Hello.exe ′)

Vous pouvez également utiliser l'applet de commande Invoke-WmiMethod:

Invoke-WmiMethod -Class Win32_Process -Name Create -ArgumentList ″ C: \\ Program Files \\ Hello.exe ″

Ou l'applet de commande Invoke-CimMethod:

Invoke-CimMethod -ClassName Win32_Process -MethodName Create -Arguments @ (CommandLine \u003d ″ C: \\ Program Files \\ Hello.exe ″)

WMI démarre le processus dans une fenêtre distincte et renvoie un objet contenant l'identificateur de processus (ProcessID) et le résultat d'exécution (ReturnValue). ReturnValue peut prendre les valeurs suivantes:

0 - Complétition réussie
2 - Accès refusé
3 - Privilège insuffisant
8 - Échec inconnu
9 - Chemin introuvable
21 - Paramètre invalide

Appeler la commande

L'applet de commande Invoke-Command peut exécuter des commandes sur un ordinateur local ou distant à l'aide de WinRM. Par exemple, pour exécuter notre programme sur l'ordinateur local, utilisez la commande:

Invoke-Command -ScriptBlock (″ C: \\ ′ Program Files ′ \\ Hello.exe ″)

Si nécessaire, le programme peut transmettre des arguments:

Invoke-Command -ScriptBlock (C: \\ ′ Program Files ′ \\ Hello.exe ″ Hello, world ″)

Veuillez noter que Invoke-Command n'est pas très convivial avec les espaces, donc pour éviter les erreurs, vous devez créer des guillemets. Cependant, de tels problèmes peuvent être évités, par exemple, en combinant l'utilisation de l'applet de commande avec l'opérateur &:

Invoke-Command -ScriptBlock (& \u200b\u200b′ C: \\ Program Files \\ Hello.exe ′)

Fondamentalement, Invoke-Command est utilisé pour le contrôle à distance, son principal avantage est la possibilité de s'exécuter simultanément sur plusieurs ordinateurs. Par exemple:

Invoke-Command -ScriptBlock (″ C: \\ ′ Program Files ′ \\ Hello.exe ″) -ComputerName SRV1, SRV2, SRV3

$ scriptblock \u003d (″ C: \\ ′ Program Files ′ \\ Hello.exe ″)
$ Ordinateurs \u003d @ (′ SRV1 ′, ′ SRV2 ′, ′ SRV3 ′)
Invoke-Command -ScriptBlock $ scriptblock -ComputerName $ Computers

Par défaut, l'applet de commande renvoie le résultat de l'exécution du programme et si vous l'exécutez en arrière-plan (le paramètre -AsJob), elle renvoie un objet Job:

Invoke-Command -ScriptBlock (C: \\ ′ Program Files ′ \\ Hello.exe) -ComputerName localhost -AsJob -JobName Hello

Invoke-item

L'applet de commande Invoke-Item est conçue pour appliquer une action par défaut à un fichier. Vous pouvez donc exécuter le fichier exécutable avec la commande:

Invoke-Item -Path ″ C: \\ Program Files \\ Hello.exe ″

Cependant, il est plus pratique d'utiliser un Invoke-Item pour ouvrir un certain type de fichier. Par exemple, nous allons ouvrir un fichier texte:

Invoke-Item -Path ″ C: \\ Files \\ test.txt ″

Et donc tous les fichiers texte du dossier:

Invoke-Item -Path ″ C: \\ Files \\ *. Txt ″

CMD

Et enfin, une autre façon de démarrer un programme à partir de PowerShell est d'utiliser le shell cmd. La méthode est assez «indirecte», mais fonctionne néanmoins. La commande suivante démarre une nouvelle instance de cmd, y exécute le programme spécifié, quitte cmd et renvoie le résultat:

cmd / c ″ C: \\ Program Files \\ Hello.exe ″

Une telle abondance de façons d'exécuter le programme fournit PoSh. Et chacun d'eux est bon pour certaines situations.

Soit dit en passant, l'article a été écrit sur la base de PowerShell: Deep Dive et Best Practice. Je recommande la lecture, il y a encore beaucoup de choses intéressantes.

Il existe plusieurs façons d'exécuter un script, les principales sont les suivantes:

Lancez PowerShell et exécutez-y le script (entrez le chemin d'accès au fichier et le nom de fichier, par exemple, comme ceci: C: \\ Scripts \\ test.ps1, ou accédez au dossier de script avec la commande cd C: \\ Scripts et exécutez-le avec la commande. \\ test.ps1) Un shell peut être trouvé et lancé de plusieurs façons. Une façon consiste à passer par le menu Démarrer. Pour Windows 7 - allez dans "Tous les programmes" - "Accessoires" - "Windows PowerShell" et démarrez le shell "Windows PowerShell". Pour Windows 10 - vous devez trouver le groupe avec la lettre "W" et vous y trouverez "Windows PowerShell".
Lancer l'environnement de script intégré Windows PowerShell ISE - Il s'agit d'un programme - un environnement de développement qui vous permet de modifier et de déboguer des scripts PowerShell, qui est également par défaut avec PowerShell lui-même. En le lançant, il vous suffit de cliquer sur le bouton "Ouvrir" ou allez dans le menu Fichier - Ouvrir et sélectionnez le script dont vous avez besoin, puis appuyez sur F5 ou le bouton "Exécuter le script". Vous pouvez trouver Windows PowerShell ISE au même endroit que le shell PowerShell - dans le menu Démarrer .
Exécuter la ligne de commande standard et écrivez-y:
powerShell -fichier<имя_скрипта> (exemple: powershell -file myscript.ps1)

Si vous n'avez jamais exécuté de scripts PowerShell auparavant, vous recevrez probablement un message: Impossible de télécharger le fichier.<имя_скрипта>, car l'exécution de scripts est interdite pour ce système. Tapez "get-help about_signing" pour plus d'informations. Cela est dû au fait que pour des raisons de sécurité et pour éviter l'exécution accidentelle de code malveillant, tous les scripts doivent être signés numériquement.

Comment autoriser l'exécution de script PowerShell non signé?

1. Dans PowerShellAvant d'exécuter le script, exécutez la commande qui permet l'exécution de scripts non signés pour la session shell actuelle:

Set-ExecutionPolicy RemoteSigned -Scope Process

2. Au démarrage à partir de la ligne de commande standard utilisez le paramètre -executionpolicy, c'est-à-dire exécutez le script comme ceci:

<имя_скрипта>

Les deux méthodes définissent la stratégie uniquement pour la session en cours, tandis que la stratégie de sécurité d'exécution du script PowerShell spécifiée dans le registre ne sera pas modifiée et restera la même. Si vous souhaitez modifier la politique de sécurité pour exécuter des scripts «de manière permanente», utilisez cette méthode:

3. Autoriser Launch Forever: exécutez PowerShell en tant qu'administrateur, puis exécutez la commande:

Set-ExecutionPolicy RemoteSigned

Remarque:Si le script a été téléchargé depuis Internet, afin d'éviter la demande de confirmation du lancement, vous devez utiliser Bypass au lieu de RemoteSigned - désactivez complètement toutes les demandes et avertissements.

Comment exécuter un script PowerShell en arrière-plan?

Pour ce faire, utilisez simplement le paramètre de démarrage -WindowStyle, qui peut prendre les valeurs: Normal, Minimized, Maximized et Hidden. Ainsi, pour exécuter un script non signé en arrière-plan, vous devez exécuter la commande:

powershell -executionpolicy RemoteSigned -WindowStyle Hidden -file<имя_скрипта>

Vous pouvez également éventuellement ajouter -NonInteractive pour que le script ne pose aucune question. Ainsi, le script s'exécutera de manière invisible pour l'utilisateur. Soyez prudent en utilisant cette méthode.

Exécution d'un script PowerShell avec des paramètres

En fait, le lancement doit être fait comme si vous lanciez un programme régulier ou un fichier bat avec des paramètres. Par exemple, pour exécuter un script avec des paramètres à partir de la commande, vous pouvez écrire la commande suivante:

powershell -executionpolicy RemoteSigned -file<имя_скрипта> param1 param2 "un autre paramètre de texte"

Dans le script lui-même, vous pouvez obtenir ces paramètres comme ceci:

Param ($ var1, $ var2, $ var3) echo $ var1, $ var2, $ var3

Dans l'environnement intégré PowerShell ISE, vous pouvez exécuter le script avec des paramètres de la même manière à l'aide de la zone de commande.

Comment exécuter un script PowerShell à l'aide d'un raccourci?

Il existe deux façons d'accomplir cette tâche:

Créez un fichier bat / cmd dans lequel écrire une commande pour exécuter le script (vous vous êtes familiarisé avec les paramètres ci-dessus)
Créez un raccourci vers PowerShell, qui se trouve dans le dossier c: \\ Windows \\ System32 \\ WindowsPowerShell \\ v<версия>\\ et dans les propriétés du raccourci dans le champ "Objet", ajoutez les paramètres nécessaires.

Ainsi, par exemple, pour exécuter le script powershell lorsqu'un utilisateur se connecte, vous pouvez simplement créer un raccourci, comme décrit au paragraphe 2, et le mettre au démarrage. En outre, la création d'un raccourci de l'une des manières ci-dessus facilitera l'exécution du script en tant qu'administrateur ou au nom de tout autre utilisateur en tant que programme normal.

Le langage de script PowerShell est un outil assez puissant pour résoudre divers problèmes, mais il peut être utilisé non seulement pour de bonnes choses, mais aussi au détriment, par conséquent, utilisez-le à bon escient;)

Bonjour à tous aujourd'hui, je veux vous dire comment exécuter le script PowerShell sur Windows. Imaginez une situation où vous avez écrit un script qui simplifie considérablement l'affichage des informations sur Active Directory, vous ouvrez le composant logiciel enfichable PowerShell, entrez le chemin d'accès à votre script, appuyez sur Entrée et obtenez une erreur.

Impossible de télécharger le fichier.<путь к вашему файлу>, car l'exécution de scripts est interdite pour ce système. Tapez "get-help about_signing" pour plus d'informations.

Nous regardons comment le résoudre.

PowerShell dispose d'un certain nombre de modes d'exécution qui déterminent le type de code autorisé à s'exécuter. Tout cela est géré par la clé de registre vivant dans HKLM. Il existe 4 modes d'exécution différents:

Limité (Restreint): La stratégie d'exécution par défaut n'autorise pas les scripts et autorise uniquement les commandes interactives.

Tous signés (Tous signés): permet à tous les scripts de fonctionner. Certes, tous les scripts et fichiers de configuration doivent être signés par un éditeur de confiance; ce mode vous expose au risque d'exécuter des scripts signés (mais malveillants) après avoir reçu une confirmation de confiance dans l'éditeur.

Supprimé signé(Signé à distance): les scripts locaux fonctionnent sans signature. Tous les scripts téléchargés doivent être signés numériquement.

Illimité (Sans restriction): Tous les scripts et fichiers de configuration obtenus à partir d'applications de communication comme Microsoft Outlook, Internet Explorer, Outlook Express et Windows Messenger fonctionnent après avoir confirmé que vous comprenez que le fichier provient d'Internet; aucune signature numérique n'est requise; Ce mode vous expose au risque de scripts malveillants non signés.

Par défaut, PowerShell utilise le mode restreint. Dans ce mode, PowerShell fonctionne uniquement comme un shell interactif. Il ne permet pas aux scripts de fonctionner et télécharge uniquement les fichiers de configuration signés par un éditeur de confiance.

Autoriser l'exécution de scripts PowerShell

Pour exécuter des scripts créés par vous-même, vous devez activer l'exécution de scripts non approuvés à l'aide de la commande Set-ExecutionPolicy remotesigned et confirmation (Attention !!! pour exécuter cette commande, vous devez exécuter PowerShell avec les droits d'administrateur). Après cela, vous pouvez réexécuter le script.

À la question, appuyez sur Y pour activer l'exécution du script. Après ces manipulations, vous pouvez exécuter votre script.

Limité (Restreint): La stratégie d'exécution par défaut n'autorise pas les scripts et autorise uniquement les commandes interactives.

Supprimé signé(Signé à distance): les scripts locaux fonctionnent sans signature. Tous les scripts téléchargés doivent être signés numériquement.

Si vous obtenez une erreur rouge gênante, dans la plupart des cas, son apparence est due au fait que vous essayez d'exécuter un script non signé. Le moyen le plus sûr de résoudre ce problème consiste à modifier la stratégie d'exécution en illimité, à exécuter le script, puis à revenir à la stratégie restreinte.

Pour modifier la stratégie d'exécution en illimité, exécutez la commande suivante dans PowerShell administratif:

Set-ExecutionPolicy Unrestricted

Vous verrez une demande de confirmation. Appuyez sur Entrée.

Vous pouvez maintenant exécuter le script téléchargé. Cependant, vous vous exposez à un risque sérieux, donc lorsque vous avez terminé d'exécuter le script, n'oubliez pas de remettre la stratégie d'exécution en mode limité. Vous pouvez le faire avec la commande suivante:

Set-ExecutionPolicy Restreint

Et encore une fois, vous verrez un message de confirmation. Appuyez sur Entrée.

C'est tout! Bonne chance!