PowerShell: exécuter une commande en tant qu'administrateur

voici un ajout à la suggestion de Shay Levi (il suffit d'ajouter ces lignes au début d'un script):

If (-NOT ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole] "Administrator"))

{   
$arguments = "& '" + $myinvocation.mycommand.definition + "'"
Start-Process powershell -Verb runAs -ArgumentList $arguments
Break
}

le script courant est passé à un nouveau processus powershell en mode administrateur (si L'Utilisateur courant a accès au mode Administrateur et que le script n'est pas lancé en tant qu'administrateur).

Auto-élévatrices script PowerShell

Windows 8.1 / PowerShell 4.0 +

:)

if (!([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole] "Administrator")) { Start-Process powershell.exe "-NoProfile -ExecutionPolicy Bypass -File `"$PSCommandPath`"" -Verb RunAs; exit }

# Your script here

Benjamin Armstrong a publié un excellent article sur les scripts Auto-élévateurs PowerShell . Il y a quelques problèmes mineurs avec son code; une version modifiée basée sur les corrections suggérées dans le commentaire est ci-dessous.

fondamentalement, il obtient l'identité associée au processus courant, vérifie s'il s'agit d'un administrateur, et si ce n'est pas le cas, crée un nouveau processus PowerShell avec des privilèges d'administrateur et termine l'ancien processus.

# Get the ID and security principal of the current user account
$myWindowsID = [System.Security.Principal.WindowsIdentity]::GetCurrent();
$myWindowsPrincipal = New-Object System.Security.Principal.WindowsPrincipal($myWindowsID);

# Get the security principal for the administrator role
$adminRole = [System.Security.Principal.WindowsBuiltInRole]::Administrator;

# Check to see if we are currently running as an administrator
if ($myWindowsPrincipal.IsInRole($adminRole))
{
    # We are running as an administrator, so change the title and background colour to indicate this
    $Host.UI.RawUI.WindowTitle = $myInvocation.MyCommand.Definition + "(Elevated)";
    $Host.UI.RawUI.BackgroundColor = "DarkBlue";
    Clear-Host;
}
else {
    # We are not running as an administrator, so relaunch as administrator

    # Create a new process object that starts PowerShell
    $newProcess = New-Object System.Diagnostics.ProcessStartInfo "PowerShell";

    # Specify the current script path and name as a parameter with added scope and support for scripts with spaces in it's path
    $newProcess.Arguments = "& '" + $script:MyInvocation.MyCommand.Path + "'"

    # Indicate that the process should be elevated
    $newProcess.Verb = "runas";

    # Start the new process
    [System.Diagnostics.Process]::Start($newProcess);

    # Exit from the current, unelevated, process
    Exit;
}

# Run your code that needs to be elevated here...

Write-Host -NoNewLine "Press any key to continue...";
$null = $Host.UI.RawUI.ReadKey("NoEcho,IncludeKeyDown");

vous pouvez créer un fichier batch ( *.bat ) qui exécute votre script powershell avec des privilèges administratifs lorsque double-cliqué. De cette façon, vous n'avez pas besoin de changer quoi que ce soit dans votre script powershell .Pour ce faire, créez un fichier batch avec le même nom et le même emplacement de votre script powershell et mettez-y le contenu suivant:

@echo off

set scriptFileName=%~n0
set scriptFolderPath=%~dp0
set powershellScriptFileName=%scriptFileName%.ps1

powershell -Command "Start-Process powershell \"-ExecutionPolicy Bypass -NoProfile -NoExit -Command `\"cd \`\"%scriptFolderPath%\`\"; & \`\".\%powershellScriptFileName%\`\"`\"\" -Verb RunAs"

C'est ça!

Voici l'explication:

si votre script powershell est dans le chemin C:\Temp\ScriptTest.ps1 , votre fichier batch doit avoir le chemin C:\Temp\ScriptTest.bat . Lorsque quelqu'un exécute ce fichier de lots, les étapes suivantes se produiront:

1. le cmd exécutera la commande

   powershell -Command "Start-Process powershell \"-ExecutionPolicy Bypass -NoProfile -NoExit -Command `\"cd \`\"C:\Temp\`\"; & \`\".\ScriptTest.ps1\`\"`\"\" -Verb RunAs"
   

2. une nouvelle session powershell s'ouvrira et la commande suivante sera exécutée:

   Start-Process powershell "-ExecutionPolicy Bypass -NoProfile -NoExit -Command `"cd \`"C:\Temp\`"; & \`".\ScriptTest.ps1\`"`"" -Verb RunAs
   

3. une autre nouvelle session powershell avec des privilèges administratifs s'ouvrira dans le dossier system32 et les arguments suivants lui seront passés:

   -ExecutionPolicy Bypass -NoProfile -NoExit -Command "cd \"C:\Temp\"; & \".\ScriptTest.ps1\""
   

4. la commande suivante sera exécutée avec des privilèges administratifs:

   cd "C:\Temp"; & ".\ScriptTest.ps1"
   

   une fois que le chemin de script et les arguments de nom sont cités deux fois, ils peuvent contenir des espaces ou des caractères de guillemets simples ( ' ).

5. le dossier actuel passera de system32 à C:\Temp et le script ScriptTest.ps1 sera exécuté. Une fois le paramètre -NoExit passé, la fenêtre ne sera pas fermée, même si votre script powershell fait une exception.

vous pouvez facilement ajouter des entrées de Registre pour obtenir un menu de contexte "exécuter en tant qu'administrateur" pour .ps1 fichiers:

New-Item -Path "Registry::HKEY_CLASSES_ROOT\Microsoft.PowershellScript.1\Shell\runas\command" `
-Force -Name '' -Value '"c:\windows\system32\windowspowershell\v1.0\powershell.exe" -noexit "%1"'

(mise à jour vers un script plus simple de @Shay)

essentiellement à HKCR:\Microsoft.PowershellScript.1\Shell\runas\command définit la valeur par défaut pour invoquer le script en utilisant Powershell.

utilisant

#Requires -RunAsAdministrator

n'a pas encore été déclaré. Il semble n'être là que depuis PowerShell 4.0.

http://technet.microsoft.com/en-us/library/hh847765.aspx

lorsque ce paramètre switch est ajouté à votre déclaration requires, il spécifie que la session Windows PowerShell dans laquelle vous êtes l'exécution du script doit commencer avec des droits d'utilisation élevés (Exécuter en tant qu'Administrateur).

pour moi, cela semble être une bonne façon de procéder, mais je ne suis pas sûr de l'expérience sur le terrain, encore. Les durées d'exécution de PowerShell 3.0 ignorent probablement cela, ou pire encore, donnent une erreur.

Lorsque le script est exécuté en tant que non-administrateur, l'erreur suivante est donnée:

Le script " StackOverflow.ps1' ne peut pas être exécuté car il contient un "#nécessite" instruction pour l'exécution en tant qu'Administrateur. Actuel Windows PowerShell session ne fonctionne pas en tant qu'administrateur. Commencer Windows PowerShell en utilisant L'option Run as Administrator, puis essayez d'exécuter le script à nouveau.

+ CategoryInfo          : PermissionDenied: (StackOverflow.ps1:String) [], ParentContainsErrorRecordException
+ FullyQualifiedErrorId : ScriptRequiresElevation

le code posté par Jonathan et Shay Levy n'a pas fonctionné pour moi.

s'il vous plaît trouver le code de travail ci-dessous:

If (-NOT ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole] "Administrator"))
{   
#"No Administrative rights, it will display a popup window asking user for Admin rights"

$arguments = "& '" + $myinvocation.mycommand.definition + "'"
Start-Process "$psHome\powershell.exe" -Verb runAs -ArgumentList $arguments

break
}
#"After user clicked Yes on the popup, your file will be reopened with Admin rights"
#"Put your code here"

vous devez relire le script avec les privilèges administratifs et vérifier si le script a été lancé dans ce mode. Ci-dessous, j'ai écrit un script qui a deux fonctions: DoElevatedOperations et DoStandardOperations . Vous devez placer votre code qui nécessite des droits d'administrateur dans le premier et standard d'opérations à la seconde. La variable IsRunAsAdmin est utilisée pour identifier le mode administrateur.

mon code est un extrait simplifié du script Microsoft qui est généré automatiquement lorsque vous créez un paquet app pour Windows Store apps.

param(
    [switch]$IsRunAsAdmin = $false
)

# Get our script path
$ScriptPath = (Get-Variable MyInvocation).Value.MyCommand.Path

#
# Launches an elevated process running the current script to perform tasks
# that require administrative privileges.  This function waits until the
# elevated process terminates.
#
function LaunchElevated
{
    # Set up command line arguments to the elevated process
    $RelaunchArgs = '-ExecutionPolicy Unrestricted -file "' + $ScriptPath + '" -IsRunAsAdmin'

    # Launch the process and wait for it to finish
    try
    {
        $AdminProcess = Start-Process "$PsHome\PowerShell.exe" -Verb RunAs -ArgumentList $RelaunchArgs -PassThru
    }
    catch
    {
        $Error[0] # Dump details about the last error
        exit 1
    }

    # Wait until the elevated process terminates
    while (!($AdminProcess.HasExited))
    {
        Start-Sleep -Seconds 2
    }
}

function DoElevatedOperations
{
    Write-Host "Do elevated operations"
}

function DoStandardOperations
{
    Write-Host "Do standard operations"

    LaunchElevated
}


#
# Main script entry point
#

if ($IsRunAsAdmin)
{
    DoElevatedOperations
}
else
{
    DoStandardOperations
}

C:\Users\"username"\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Windows PowerShell est l'endroit où réside le raccourci de PowerShell. Il va aussi à un endroit différent pour invoquer le 'exe' réel ( %SystemRoot%\system32\WindowsPowerShell\v1.0\powershell.exe ).

puisque PowerShell est piloté par le profil de l'utilisateur quand les permissions sont concernées; si votre nom d'utilisateur/profil a les permissions pour faire quelque chose alors sous ce profil, dans PowerShell vous seriez généralement en mesure de le faire aussi. Cela dit, il serait logique que vous changiez la raccourci situé sous votre profil d'utilisateur, par exemple, C:\Users\"username"\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Windows PowerShell .

droit-cliquez et cliquez Propriétés. Cliquez sur le bouton " Avancé "sous l'onglet" Raccourci "situé juste au-dessous du champ de texte" commentaires "adjacent à la droite de deux autres boutons," ouvrir L'emplacement du fichier "et" changer L'icône", respectivement.

cochez la case"Exécuter en tant qu'administrateur". Cliquez sur OK , puis appliquer et OK . Une fois de plus, cliquez avec le bouton droit de la souris sur L'icône "Windows PowerShell" située dans C:\Users\"username"\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Windows PowerShell et sélectionnez" Pin to Start Menu/Taskbar".

maintenant chaque fois que vous cliquez sur cette icône, il invoquera le UAC pour l'escalade. Après avoir sélectionné "Oui", vous remarquerez que la console PowerShell est ouverte et qu'elle porte la mention" administrateur " en haut de l'écran.

Pour aller plus loin... vous pourriez clic droit que même raccourci icône dans votre emplacement de profil de Windows PowerShell et assignez un raccourci clavier qui fera la même chose exacte que si vous avez cliqué sur l'icône récemment ajoutée. Donc, où il est dit "raccourci touche" mettre dans une combinaison clavier/bouton comme: Ctrl + Alt + P P (pour PowerShell) . Cliquez sur appliquer et OK .

maintenant, tout ce que vous avez à faire est d'appuyer sur cette combinaison de boutons que vous avez assignée et vous verrez UAC être invoqué, et après que vous avez choisi "oui" vous verrez une console PowerShell apparaître et "administrateur" affiché sur la barre de titre.

vous pouvez également forcer l'application à s'ouvrir en tant qu'administrateur. Si vous avez un compte administrateur bien sûr.

localisez le fichier, clic droit > Propriétés > raccourci > avancé et vérifiez L'exécution en tant qu'administrateur

puis cliquez sur OK.

Un certain nombre de réponses ici sont proches, mais un peu plus de travail que nécessaire.

créez un raccourci vers votre script et configurez-le pour "exécuter en tant qu'administrateur":

• créer le raccourci.
• clic droit sur le raccourci et ouvrir Properties...
• Modifier Target à partir de <script-path> à powershell <script-path>
• Cliquez Sur Avancé... et activer Run as administrator

Ce comportement est par la conception. Il y a plusieurs couches de sécurité puisque Microsoft ne voulait vraiment pas .ps1 fichiers à être le dernier virus de messagerie. Certains trouvent que cela va à l'encontre de la notion même d'automatisation des tâches, qui est juste. Le modèle de sécurité Vista+ est de "dé-automatiser"les choses, ce qui rend l'utilisateur OK.

cependant, je soupçonne que si vous lancez powershell lui-même comme élevé, il devrait être en mesure d'exécuter des fichiers par lots sans demander le mot de passe à nouveau jusqu'à ce que vous fermiez powershell.

une autre solution plus simple est que vous pouvez également clic droit sur "C:\Windows\System32\cmd.exe" et choisissez "Exécuter en tant qu'Administrateur", puis vous pouvez exécuter n'importe quelle application en tant qu'administrateur sans fournir de mot de passe.

j'ai trouvé un moyen de le faire...

créez un fichier par lot pour ouvrir votre script:

@echo off
START "" "C:\Scripts\ScriptName.ps1"

alors créer un raccourci, sur votre bureau dire (clic droit Nouveau - > raccourci ).

puis coller ceci dans l'endroit:

C:\Windows\System32\runas.exe /savecred /user:*DOMAIN*\*ADMIN USERNAME* C:\Scripts\BatchFileName.bat

Lors de la première ouverture, vous devrez entrer votre mot de passe une fois. Cela le sauvera alors dans les fenêtres Gestionnaire des justificatifs d'identité.

Après cela, vous devriez être en mesure d'exécuter en tant qu'administrateur sans avoir à entrer un nom d'utilisateur ou mot de passe.

le problème avec les réponses de @pgk et @Andrew Odri est quand vous avez des paramètres de script, spécialement quand ils sont obligatoires. Vous pouvez résoudre ce problème en utilisant l'approche suivante:

1. l'utilisateur clique droit sur le .ps1 fichier et sélectionne " Run with PowerShell": demandez-lui les paramètres à travers les boîtes de saisie (c'est une bien meilleure option que d'utiliser le HelpMessage attribut paramètre);
2. l'utilisateur exécute le script à travers la console: lui permettre de passer les paramètres désirés et laisser la console le forcer à informer les obligatoires.

Voici comment serait le code si le script avait le ComputerName et Port paramètres obligatoires:

[CmdletBinding(DefaultParametersetName='RunWithPowerShellContextMenu')]
param (
    [parameter(ParameterSetName='CallFromCommandLine')]
    [switch] $CallFromCommandLine,

    [parameter(Mandatory=$false, ParameterSetName='RunWithPowerShellContextMenu')]
    [parameter(Mandatory=$true, ParameterSetName='CallFromCommandLine')]
    [string] $ComputerName,

    [parameter(Mandatory=$false, ParameterSetName='RunWithPowerShellContextMenu')]
    [parameter(Mandatory=$true, ParameterSetName='CallFromCommandLine')]
    [UInt16] $Port
)

function Assert-AdministrativePrivileges([bool] $CalledFromRunWithPowerShellMenu)
{
    $isAdministrator = ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)

    if ($isAdministrator)
    {
        if (!$CalledFromRunWithPowerShellMenu -and !$CallFromCommandLine)
        {
            # Must call itself asking for obligatory parameters
            & "$PSCommandPath" @script:PSBoundParameters -CallFromCommandLine
            Exit
        }
    }
    else
    {
        if (!$CalledFromRunWithPowerShellMenu -and !$CallFromCommandLine)
        {
            $serializedParams = [Management.Automation.PSSerializer]::Serialize($script:PSBoundParameters)

            $scriptStr = @"
                `$serializedParams = '$($serializedParams -replace "'", "''")'

                `$params = [Management.Automation.PSSerializer]::Deserialize(`$serializedParams)

                & "$PSCommandPath" @params -CallFromCommandLine
"@

            $scriptBytes = [System.Text.Encoding]::Unicode.GetBytes($scriptStr)
            $encodedCommand = [Convert]::ToBase64String($scriptBytes)

            # If this script is called from another one, the execution flow must wait for this script to finish.
            Start-Process -FilePath 'powershell' -ArgumentList "-ExecutionPolicy Bypass -NoProfile -EncodedCommand $encodedCommand" -Verb 'RunAs' -Wait
        }
        else
        {
            # When you use the "Run with PowerShell" feature, the Windows PowerShell console window appears only briefly.
            # The NoExit option makes the window stay visible, so the user can see the script result.
            Start-Process -FilePath 'powershell' -ArgumentList "-ExecutionPolicy Bypass -NoProfile -NoExit -File ""$PSCommandPath""" -Verb 'RunAs'
        }

        Exit
    }
}

function Get-UserParameters()
{
    [string] $script:ComputerName = [Microsoft.VisualBasic.Interaction]::InputBox('Enter a computer name:', 'Testing Network Connection')

    if ($script:ComputerName -eq '')
    {
        throw 'The computer name is required.'
    }

    [string] $inputPort = [Microsoft.VisualBasic.Interaction]::InputBox('Enter a TCP port:', 'Testing Network Connection')

    if ($inputPort -ne '')
    {
        if (-not [UInt16]::TryParse($inputPort, [ref]$script:Port))
        {
            throw "The value '$inputPort' is invalid for a port number."
        }
    }
    else
    {
        throw 'The TCP port is required.'
    }
}

# $MyInvocation.Line is empty in the second script execution, when a new powershell session
# is started for this script via Start-Process with the -File option.
$calledFromRunWithPowerShellMenu = $MyInvocation.Line -eq '' -or $MyInvocation.Line.StartsWith('if((Get-ExecutionPolicy')

Assert-AdministrativePrivileges $calledFromRunWithPowerShellMenu

# Necessary for InputBox
[System.Reflection.Assembly]::Load('Microsoft.VisualBasic, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a') | Out-Null

if ($calledFromRunWithPowerShellMenu)
{
    Get-UserParameters
}

# ... script code
Test-NetConnection -ComputerName $ComputerName -Port $Port

en plus de la réponse de Shay Levy, suivez la configuration ci-dessous (juste une fois)

1. démarrez une PowerShell avec les droits D'administrateur.
2. Suivez-Débordement de Pile question PowerShell dit "exécution de scripts est désactivée sur ce système." .
3. mettez votre .ps1 fichier dans l'un des dossiers PATH , par exemple. Windows\System 32 folder

après la configuration:

1. Appuyez Sur Gagner + R
2. Invoquer powershell Start-Process powershell -Verb runAs <ps1_file>

vous pouvez maintenant exécuter tout en une seule ligne de commande. Les travaux ci-dessus sur Windows 8 Basic 64-bit.

le moyen Le plus fiable que j'ai trouvé est de l'envelopper dans une auto-élévatrices .fichier bat:

@echo off
NET SESSION 1>NUL 2>NUL
IF %ERRORLEVEL% EQU 0 GOTO ADMINTASKS
CD %~dp0
MSHTA "javascript: var shell = new ActiveXObject('shell.application'); shell.ShellExecute('%~nx0', '', '', 'runas', 0); close();"
EXIT

:ADMINTASKS

powershell -file "c:\users\joecoder\scripts\admin_tasks.ps1"

EXIT

The .bat vérifie si vous êtes déjà administrateur et relance le script en tant qu'administrateur si nécessaire. Il empêche également les fenêtres "cmd" étrangères de s'ouvrir avec le 4ème paramètre de ShellExecute() réglé à 0 .

j'utilise la solution ci-dessous. Il traite stdout / stderr via la fonction de transcription et passe le code de sortie correctement au processus parent. Vous devez ajuster le chemin de transcription/nom de fichier.

If (-NOT ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole] "Administrator"))
{ 
  echo "* Respawning PowerShell child process with elevated privileges"
  $pinfo = New-Object System.Diagnostics.ProcessStartInfo
  $pinfo.FileName = "powershell"
  $pinfo.Arguments = "& '" + $myinvocation.mycommand.definition + "'"
  $pinfo.Verb = "RunAs"
  $pinfo.RedirectStandardError = $false
  $pinfo.RedirectStandardOutput = $false
  $pinfo.UseShellExecute = $true
  $p = New-Object System.Diagnostics.Process
  $p.StartInfo = $pinfo
  $p.Start() | Out-Null
  $p.WaitForExit()
  echo "* Child process finished"
  type "C:/jenkins/transcript.txt"
  Remove-Item "C:/jenkins/transcript.txt"
  Exit $p.ExitCode
} Else {
  echo "Child process starting with admin privileges"
  Start-Transcript -Path "C:/jenkins/transcript.txt"
}

# Rest of your script goes here, it will be executed with elevated privileges

je n'ai pas vu ma façon de le faire avant, donc, essayez ceci. Il est beaucoup plus facile à suivre et a une empreinte beaucoup plus petite:

if([bool]([Security.Principal.WindowsIdentity]::GetCurrent()).Groups -notcontains "S-1-5-32-544") {
    Start Powershell -ArgumentList "& '$MyInvocation.MyCommand.Path'" -Verb runas
    }

très simplement, si la session courante de Powershell a été appelée avec des privilèges d'administrateur, le groupe D'administrateur Sid bien connu apparaîtra dans les groupes lorsque vous saisirez l'identité courante. Même si le compte est un membre de ce groupe, le SID ne se présentera pas à moins que le processus ait été invoqué avec des références élevées.

presque toutes ces réponses sont une variation sur la méthode immensément populaire de Ben Armstrong de Microsoft de la façon de l'accomplir tout en ne saisissant pas vraiment ce qu'il fait réellement et comment autrement émuler la même routine.

pour ajouter la sortie de la commande à un nom de fichier texte qui inclut la date courante vous pouvez faire quelque chose comme ceci:

$winupdfile = 'Windows-Update-' + $(get-date -f MM-dd-yyyy) + '.txt'
if (!([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole] "Administrator")) { Start-Process powershell.exe "-NoProfile -ExecutionPolicy Bypass -Command `"Get-WUInstall -AcceptAll | Out-File $env:USERPROFILE$winupdfile -Append`"" -Verb RunAs; exit } else { Start-Process powershell.exe "-NoProfile -ExecutionPolicy Bypass -Command `"Get-WUInstall -AcceptAll | Out-File $env:USERPROFILE$winupdfile -Append`""; exit }

ceci est une clarification ...

Le powershell RUNAS / SAVECRED justificatif d'identité "n'est pas sûr", il a essayé et il ajoute l'administrateur de l'identité et le mot de passe dans le cache d'informations d'identification et peuvent être utilisés ailleurs OUPS!. Si vous avez fait cela, je vous suggère de vérifier et de supprimer l'entrée.

réviser votre programme ou code parce que la Politique de Microsoft est que vous ne pouvez pas avoir le code d'utilisateur et d'administrateur mélangé dans le même blob de code sans L'UAC (le point d'entrée) à exécuter le programme en tant qu'administrateur. Ce serait sudo (même chose) sur Linux.

L'UAC a 3 types, dont voir, un prompt ou un point d'entrée généré dans le Manifeste du programme. Il n'élève pas le programme donc s'il n'y a pas de UAC et qu'il a besoin d'administrateur, il échouera. L'UAC bien que comme une exigence d'administrateur est bonne, elle empêche l'exécution de code sans authentification et empêche le scénario de codes mixtes exécuter au niveau de l'utilisateur.

en ajoutant mes 2 cents. Ma version simple basée sur net session qui fonctionne tout le temps jusqu'à présent sous Windows 7 / Windows 10. Pourquoi compliquer?

if (!(net session)) {$path =  "& '" + $myinvocation.mycommand.definition + "'" ; Start-Process powershell -Verb runAs -ArgumentList $path ; exit}

il suffit d'ajouter au haut du script et il sera exécuté en tant qu'administrateur.

Il s'avère que c'était trop facile. Tout ce que vous avez à faire est d'exécuter une commande en tant qu'administrateur. Puis tapez explorer.exe et appuyez sur Entrée. Qui ouvre Windows Explorer . Maintenant, cliquez à droite sur votre script PowerShell que vous voulez lancer, choisissez "run with PowerShell" qui le lancera en mode administrateur.

Il peut vous demander d'activer la politique à exécuter, tapez Y et appuyez sur entrée. Maintenant le script s'exécute en PowerShell en tant qu'administrateur. En cas il est tout rouge, ce qui veut dire que votre police n'a pas encore pris effet. Alors réessayez et ça devrait marcher.