So führen Sie eine EXE-Datei in PowerShell mit Parametern mit Leerzeichen und Anführungszeichen aus

Wie führen Sie den folgenden Befehl in PowerShell aus?

C: \ Programme \ IIS \ Microsoft Web Deploy \ msdeploy.exe -verb: sync -source: dbfullsql = "Datenquelle = mysource; Integrierte Sicherheit = false; Benutzer-ID = sa; Pwd = sapass !; Database = mydb;" -dest: dbfullsql = "Datenquelle =. \ mydestsource; Integrierte Sicherheit = false; Benutzer-ID = sa; Pwd = sapass !; Datenbank = mydb;", Computername = 10.10.10.10, Benutzername = Administrator, Kennwort = Administratorpass "

Wenn PowerShell einen Befehl sieht, der mit einer Zeichenfolge beginnt, wertet es nur die Zeichenfolge aus, dh, es wird normalerweise auf dem Bildschirm angezeigt, z. B.:

PS> "Hello World"
Hello World

Wenn PowerShell die Zeichenfolge als Befehlsnamen interpretieren soll, verwenden Sie den Aufrufoperator (&) wie folgt:

PS> & 'C:\Program Files\IIS\Microsoft Web Deploy\msdeploy.exe'

Danach müssen Sie wahrscheinlich nur noch Parameter / Argument-Paare in Anführungszeichen setzen, die Leerzeichen und / oder Anführungszeichen enthalten. Wenn Sie eine solche EXE-Datei mit komplexen Befehlszeilenargumenten aufrufen, ist es normalerweise sehr hilfreich, ein Tool zu haben, das Ihnen zeigt, wie PowerShell die Argumente an die EXE-Datei sendet. Die PowerShell Community Extensions verfügen über ein solches Tool. Es heißt Echoargs. Sie ersetzen einfach die EXE-Datei durch Echoargs, lassen alle Argumente an Ort und Stelle und zeigen Ihnen, wie die EXE-Datei die Argumente empfängt, zum Beispiel:

PS> echoargs -verb:sync -source:dbfullsql="Data Source=mysource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;" -dest:dbfullsql="Data Source=.\mydestsource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;",computername=10.10.10.10,username=administrator,password=adminpass

Arg 0 is <-verb:sync>
Arg 1 is <-source:dbfullsql=Data>
Arg 2 is <Source=mysource;Integrated>
Arg 3 is <Security=false;User>
Arg 4 is <ID=sa;Pwd=sapass!;Database=mydb;>
Arg 5 is <-dest:dbfullsql=Data>
Arg 6 is <Source=.\mydestsource;Integrated>
Arg 7 is <Security=false;User>
Arg 8 is <ID=sa;Pwd=sapass!;Database=mydb; computername=10.10.10.10 username=administrator password=adminpass>

Mit Echoargs können Sie experimentieren, bis Sie es richtig verstanden haben, zum Beispiel:

PS> echoargs -verb:sync "-source:dbfullsql=Data Source=mysource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;"
Arg 0 is <-verb:sync>
Arg 1 is <-source:dbfullsql=Data Source=mysource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;>

Es stellte sich heraus, dass ich mich zuvor zu sehr bemüht hatte, die doppelten Anführungszeichen um die Verbindungszeichenfolge beizubehalten. Anscheinend ist das nicht notwendig, weil sogar cmd.exe diese entfernen wird.

Übrigens, Hut ab vor dem PowerShell-Team. Sie waren sehr hilfreich, um mir die spezifische Beschwörung von einfachen und doppelten Anführungszeichen zu zeigen, um das gewünschte Ergebnis zu erzielen - wenn Sie die internen doppelten Anführungszeichen beibehalten müssen. :-) Sie erkennen auch, dass dies ein Schmerzbereich ist, aber sie werden von der Anzahl der Menschen bestimmt, die von einem bestimmten Problem betroffen sind. Wenn dies ein Schmerzbereich für Sie ist, stimmen Sie diese PowerShell-Fehlerübermittlung ab .

Weitere Informationen zum Parsen von PowerShell finden Sie in meiner Effective PowerShell-Blogserie - insbesondere in Punkt 10 - "Grundlegendes zu PowerShell-Parsing-Modi".

UPDATE 04.04.2012: Diese Situation wird in PowerShell V3 viel einfacher zu handhaben. Weitere Informationen finden Sie in diesem Blogbeitrag .

Fügen Sie einfach den Operator & vor dem EXE-Namen hinzu. Hier ist ein Befehl zum Installieren von SQL Server Express im Stummschaltungsmodus:

$fileExe = "T:\SQLEXPRADV_x64_ENU.exe"
$CONFIGURATIONFILE = "T:\ConfSetupSql2008Express.ini"

& $fileExe  /CONFIGURATIONFILE=$CONFIGURATIONFILE

Ich hatte Leerzeichen sowohl im Befehl als auch in den Parametern, und das hat bei mir funktioniert:

$Command = "E:\X64\Xendesktop Setup\XenDesktopServerSetup.exe"
$Parms = "/COMPONENTS CONTROLLER,DESKTOPSTUDIO,DESKTOPDIRECTOR,LICENSESERVER,STOREFRONT /PASSIVE /NOREBOOT /CONFIGURE_FIREWALL /NOSQL"

$Prms = $Parms.Split(" ")
& "$Command" $Prms

Es ist im Grunde dasselbe wie Akiras Antwort, aber dies funktioniert, wenn Sie Ihre Befehlsparameter dynamisch erstellen und in eine Variable einfügen.

Das hat bei mir funktioniert:

& 'D:\Server\PSTools\PsExec.exe' @('\\1.1.1.1', '-accepteula', '-d', '-i', $id, '-h', '-u', 'domain\user', '-p', 'password', '-w', 'C:\path\to\the\app', 'java', '-jar', 'app.jar')

Fügen Sie einfach Pfade oder Verbindungszeichenfolgen in ein Array-Element ein und teilen Sie die anderen Elemente in jeweils ein Array-Element auf.

Hier gibt es viele andere Optionen: https://social.technet.microsoft.com/wiki/contents/articles/7703.powershell-running-executables.aspx

Microsoft sollte dies einfacher und kompatibler mit der Syntax der Eingabeaufforderung machen.

Es gibt einige Methoden, mit denen Sie dies tun können.

Es gibt andere Methoden wie die Verwendung des Call Operator ( & ), des Cmdlets Invoke-Expression usw. Sie gelten jedoch als unsicher. Microsoft empfiehlt die Verwendung von Start-Process .

Methode 1

Ein einfaches Beispiel

Start-Process -NoNewWindow -FilePath "C:\wamp64\bin\mysql\mysql5.7.19\bin\mysql" -ArgumentList "-u root","-proot","-h localhost"

In Ihrem Fall

Start-Process -NoNewWindow -FilePath "C:\Program Files\IIS\Microsoft Web Deploy\msdeploy.exe" -ArgumentList "-verb:sync","-source:dbfullsql=`"Data Source=mysource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;`"","-dest:dbfullsql=`"Data Source=.\mydestsource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;`"","computername=10.10.10.10","username=administrator","password=adminpass"

Bei dieser Methode trennen Sie jeden Parameter in der ArgumentList durch Kommas.

Methode 2

Einfaches Beispiel

Start-Process -NoNewWindow -FilePath "C:\wamp64\bin\mysql\mysql5.7.19\bin\mysql" -ArgumentList "-u root -proot -h localhost"

In Ihrem Fall

Start-Process -NoNewWindow -FilePath "C:\Program Files\IIS\Microsoft Web Deploy\msdeploy.exe" -ArgumentList "-verb:sync -source:dbfullsql=`"Data Source=mysource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;`" -dest:dbfullsql=`"Data Source=.\mydestsource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;`",computername=10.10.10.10,username=administrator,password=adminpass"

Diese Methode ist einfacher, da Sie Ihre Parameter auf einmal eingeben können.

Beachten Sie, dass Sie in Powershell, um das Anführungszeichen (") in einer Zeichenfolge darzustellen, den gravierenden Akzent (`) einfügen sollten (dies ist die Taste über der Tabulatortaste in der US-Tastatur).

Der Parameter -NoNewWindow wird verwendet, um den neuen Prozess im aktuellen Konsolenfenster anzuzeigen. Standardmäßig öffnet Windows PowerShell ein neues Fenster.

Referenzen: Powershell / Scripting / Start-Prozess

Siehe diese Seite: https://slai.github.io/posts/powershell-and-external-commands-done-right/

Zusammenfassung mit vshadow als externe ausführbare Datei:

$exe = "H:\backup\scripts\vshadow.exe"
&$exe -p -script=H:\backup\scripts\vss.cmd E: M: P:

Falls sich jemand fragt, wie man einfach eine ausführbare Datei ausführt:

.....>. \ file.exe

oder

......> vollständiger \ Pfad \ zu \ file.exe

Ich konnte meinen ähnlichen Befehl mit dem folgenden Ansatz zum Laufen bringen:

msdeploy.exe -verb=sync "-source=dbFullSql=Server=THESERVER;Database=myDB;UID=sa;Pwd=saPwd" -dest=dbFullSql=c:\temp\test.sql

Für Ihren Befehl (nicht, dass es jetzt viel hilft) würden die Dinge ungefähr so ​​aussehen:

msdeploy.exe -verb=sync "-source=dbfullsql=Server=mysource;Trusted_Connection=false;UID=sa;Pwd=sapass!;Database=mydb;" "-dest=dbfullsql=Server=mydestsource;Trusted_Connection=false;UID=sa;Pwd=sapass!;Database=mydb;",computername=10.10.10.10,username=administrator,password=adminpass

Die wichtigsten Punkte sind:

• Verwenden Sie Anführungszeichen um das Quellargument und entfernen Sie die eingebetteten Anführungszeichen um die Verbindungszeichenfolge
• Verwenden Sie beim Erstellen der SQL-Verbindungszeichenfolge die alternativen Schlüsselnamen, in denen keine Leerzeichen enthalten sind. Verwenden Sie beispielsweise "UID" anstelle von "Benutzer-ID", "Server" anstelle von "Datenquelle", "Trusted_Connection" anstelle von "Integrierte Sicherheit" usw. Ich konnte es erst zum Laufen bringen, nachdem ich alle Leerzeichen aus der Verbindungszeichenfolge entfernt hatte.

Ich habe nicht versucht, den Teil "Computername" am Ende der Befehlszeile hinzuzufügen, aber hoffentlich helfen diese Informationen anderen, die dies lesen, jetzt, ihrem gewünschten Ergebnis näher zu kommen.

Neue Escape-Zeichenfolge in PowerShell V3, zitiert aus den Funktionen der neuen V3-Sprache :

Einfachere Wiederverwendung von Befehlszeilen aus Cmd.exe

Das Web ist voll von Befehlszeilen, die für Cmd.exe geschrieben wurden. Diese Befehlszeilen funktionieren in PowerShell häufig genug. Wenn sie jedoch bestimmte Zeichen enthalten, z. B. ein Semikolon (;), ein Dollarzeichen ($) oder geschweifte Klammern, müssen Sie einige Änderungen vornehmen und möglicherweise einige Anführungszeichen hinzufügen. Dies schien die Ursache vieler kleinerer Kopfschmerzen zu sein.

Um dieses Szenario zu lösen, haben wir eine neue Methode hinzugefügt, um das Parsen von Befehlszeilen zu umgehen. Wenn Sie einen magischen Parameter -% verwenden, stoppen wir das normale Parsen Ihrer Befehlszeile und wechseln zu etwas viel Einfacherem. Wir stimmen nicht mit Anführungszeichen überein. Wir hören nicht beim Semikolon auf. Wir erweitern keine PowerShell-Variablen. Wir erweitern Umgebungsvariablen, wenn Sie die Cmd.exe-Syntax verwenden (z. B.% TEMP%). Davon abgesehen werden die Argumente bis zum Ende der Zeile (oder Pipe, wenn Sie Piping verwenden) unverändert übergeben. Hier ist ein Beispiel:

PS> echoargs.exe --% %USERNAME%,this=$something{weird}
Arg 0 is <jason,this=$something{weird}>

Sie können verwenden:

Start-Process -FilePath "C:\Program Files\IIS\Microsoft Web Deploy\msdeploy.exe" -ArgumentList "-verb:sync -source:dbfullsql="Data Source=mysource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;" -dest:dbfullsql="Data Source=.\mydestsource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;",computername=10.10.10.10,username=administrator,password=adminpass"

Das Wichtigste dabei ist, dass FilePath laut Hilfe auf Position 0 stehen muss. Geben Sie einfach ein, um die Hilfe für ein Commandlet aufzurufen Get-Help <Commandlet-name> -Detailed. In diesem Fall ist es Get-Help Start-Process -Detailed.

Ich habe alle Vorschläge ausprobiert, konnte aber immer noch nicht msiexec.exemit Parametern ausgeführt werden, die Leerzeichen enthielten. Meine Lösung endete also mit System.Diagnostics.ProcessStartInfo:

# can have spaces here, no problems
$settings = @{
  CONNECTION_STRING = "... ..."
  ENTITY_CONTEXT = "... ..."
  URL = "..."
}

$settingsJoined = ($settings.Keys | % { "$_=""$($settings[$_])""" }) -join " "
$pinfo = New-Object System.Diagnostics.ProcessStartInfo
$pinfo.WorkingDirectory = $ScriptDirectory
$pinfo.FileName = "msiexec.exe"
$pinfo.RedirectStandardError = $true
$pinfo.RedirectStandardOutput = $true
$pinfo.UseShellExecute = $false
$pinfo.Arguments = "/l* install.log /i installer.msi $settingsJoined"
$p = New-Object System.Diagnostics.Process
$p.StartInfo = $pinfo
$p.Start() | Out-Null
$p.WaitForExit()
$stdout = $p.StandardOutput.ReadToEnd()

Das hat bei mir funktioniert:

PowerShell.exe -Command "& ""C:\Some Script\Path With Spaces.ps1"""

Der Schlüssel scheint zu sein, dass der gesamte Befehl in äußere Anführungszeichen eingeschlossen ist, das kaufmännische Und "&" verwendet wird, um anzugeben, dass eine andere untergeordnete Befehlsdatei ausgeführt wird, und dann schließlich (doppelte-doppelte-) Anführungszeichen um den Pfad / Dateinamen mit Leerzeichen maskiert werden in wollten Sie in erster Linie ausführen.

Dies ist auch der Abschluss der einzigen Problemumgehung für das MS Connect-Problem, bei der -File keine Nicht-Null-Rückkehrcodes zurückgibt und -Command die einzige Alternative ist. Bisher wurde jedoch angenommen, dass eine Einschränkung von -Command darin besteht, dass keine Leerzeichen unterstützt werden. Ich habe auch dieses Feedback-Element aktualisiert.

http://connect.microsoft.com/PowerShell/feedback/details/750653/powershell-exe-doesn-t-return-correct-exit-codes-when-using-the-file-option

Eine alternative Antwort ist die Verwendung eines Base64- codierten Befehlsschalters:

powershell -EncodedCommand "QwA6AFwAUAByAG8AZwByAGEAbQAgAEYAaQBsAGUAcwBcAEkASQBTAFwATQBpAGMAcgBvAHMAbwBmAHQAIABXAGUAYgAgAEQAZQBwAGwAbwB5AFwAbQBzAGQAZQBwAGwAbwB5AC4AZQB4AGUAIAAtAHYAZQByAGIAOgBzAHkAbgBjACAALQBzAG8AdQByAGMAZQA6AGQAYgBmAHUAbABsAHMAcQBsAD0AIgBEAGEAdABhACAAUwBvAHUAcgBjAGUAPQBtAHkAcwBvAHUAcgBjAGUAOwBJAG4AdABlAGcAcgBhAHQAZQBkACAAUwBlAGMAdQByAGkAdAB5AD0AZgBhAGwAcwBlADsAVQBzAGUAcgAgAEkARAA9AHMAYQA7AFAAdwBkAD0AcwBhAHAAYQBzAHMAIQA7AEQAYQB0AGEAYgBhAHMAZQA9AG0AeQBkAGIAOwAiACAALQBkAGUAcwB0ADoAZABiAGYAdQBsAGwAcwBxAGwAPQAiAEQAYQB0AGEAIABTAG8AdQByAGMAZQA9AC4AXABtAHkAZABlAHMAdABzAG8AdQByAGMAZQA7AEkAbgB0AGUAZwByAGEAdABlAGQAIABTAGUAYwB1AHIAaQB0AHkAPQBmAGEAbABzAGUAOwBVAHMAZQByACAASQBEAD0AcwBhADsAUAB3AGQAPQBzAGEAcABhAHMAcwAhADsARABhAHQAYQBiAGEAcwBlAD0AbQB5AGQAYgA7ACIALABjAG8AbQBwAHUAdABlAHIAbgBhAG0AZQA9ADEAMAAuADEAMAAuADEAMAAuADEAMAAsAHUAcwBlAHIAbgBhAG0AZQA9AGEAZABtAGkAbgBpAHMAdAByAGEAdABvAHIALABwAGEAcwBzAHcAbwByAGQAPQBhAGQAbQBpAG4AcABhAHMAcwAiAA=="

Nach der Dekodierung sehen Sie, dass es sich um das Original-Snippet des OP handelt, bei dem alle Argumente und doppelten Anführungszeichen erhalten bleiben.

powershell.exe -EncodedCommand

Accepts a base-64-encoded string version of a command. Use this parameter
to submit commands to Windows PowerShell that require complex quotation
marks or curly braces.

Der ursprüngliche Befehl:

 C:\Program Files\IIS\Microsoft Web Deploy\msdeploy.exe -verb:sync -source:dbfullsql="Data Source=mysource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;" -dest:dbfullsql="Data Source=.\mydestsource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;",computername=10.10.10.10,username=administrator,password=adminpass"

Wenn es als Base64 codiert wird, wird daraus Folgendes:

QwA6AFwAUAByAG8AZwByAGEAbQAgAEYAaQBsAGUAcwBcAEkASQBTAFwATQBpAGMAcgBvAHMAbwBmAHQAIABXAGUAYgAgAEQAZQBwAGwAbwB5AFwAbQBzAGQAZQBwAGwAbwB5AC4AZQB4AGUAIAAtAHYAZQByAGIAOgBzAHkAbgBjACAALQBzAG8AdQByAGMAZQA6AGQAYgBmAHUAbABsAHMAcQBsAD0AIgBEAGEAdABhACAAUwBvAHUAcgBjAGUAPQBtAHkAcwBvAHUAcgBjAGUAOwBJAG4AdABlAGcAcgBhAHQAZQBkACAAUwBlAGMAdQByAGkAdAB5AD0AZgBhAGwAcwBlADsAVQBzAGUAcgAgAEkARAA9AHMAYQA7AFAAdwBkAD0AcwBhAHAAYQBzAHMAIQA7AEQAYQB0AGEAYgBhAHMAZQA9AG0AeQBkAGIAOwAiACAALQBkAGUAcwB0ADoAZABiAGYAdQBsAGwAcwBxAGwAPQAiAEQAYQB0AGEAIABTAG8AdQByAGMAZQA9AC4AXABtAHkAZABlAHMAdABzAG8AdQByAGMAZQA7AEkAbgB0AGUAZwByAGEAdABlAGQAIABTAGUAYwB1AHIAaQB0AHkAPQBmAGEAbABzAGUAOwBVAHMAZQByACAASQBEAD0AcwBhADsAUAB3AGQAPQBzAGEAcABhAHMAcwAhADsARABhAHQAYQBiAGEAcwBlAD0AbQB5AGQAYgA7ACIALABjAG8AbQBwAHUAdABlAHIAbgBhAG0AZQA9ADEAMAAuADEAMAAuADEAMAAuADEAMAAsAHUAcwBlAHIAbgBhAG0AZQA9AGEAZABtAGkAbgBpAHMAdAByAGEAdABvAHIALABwAGEAcwBzAHcAbwByAGQAPQBhAGQAbQBpAG4AcABhAHMAcwAiAA==

und so replizieren Sie zu Hause:

$command = 'C:\Program Files\IIS\Microsoft Web Deploy\msdeploy.exe -verb:sync -source:dbfullsql="Data Source=mysource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;" -dest:dbfullsql="Data Source=.\mydestsource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;",computername=10.10.10.10,username=administrator,password=adminpass"'
$bytes = [System.Text.Encoding]::Unicode.GetBytes($command)
$encodedCommand = [Convert]::ToBase64String($bytes)
$encodedCommand

#  The clip below copies the base64 string to your clipboard for right click and paste.
$encodedCommand | Clip

Sie können exe-Dateien auf verschiedene Arten auf Powershell ausführen. Wenn Sie beispielsweise unrar.exe ausführen und eine .rar-Datei extrahieren möchten, können Sie dies einfach in Powershell schreiben:

$extract_path = "C:\Program Files\Containing folder";
$rar_to_extract = "C:\Path_to_arch\file.rar"; #(or.exe if its a big file)  
C:\Path_here\Unrar.exe x -o+ -c- $rar_to_extract $extract_path;

Manchmal funktioniert dies jedoch nicht, sodass Sie den Parameter & wie oben gezeigt verwenden müssen: Mit vboxmanage.exe (einem Tool zum Verwalten von virtuellen Virtualbox-Maschinen) müssen Sie beispielsweise die Parameter außerhalb der Zeichenfolge wie folgt ohne Anführungszeichen aufrufen:

> $vmname = "misae_unrtes_1234123"; #(name too long, we want to change this)
> & 'C:\Program Files\Oracle\VirtualBox\VBoxManage.exe' modifyvm $vmname --name UBUNTU;

Wenn Sie einfach eine archivierte winrar-Datei als EXE-Datei aufrufen möchten, können Sie sie auch mit dem Cmdlet invoke-command und einem Silent-Parameter / S entpacken (es wird sich im selben Ordner extrahieren, in dem es komprimiert wurde).

> Invoke-Command -ScriptBlock { C:\Your-path\archivefile.exe /S };

Es gibt also verschiedene Möglichkeiten, EXE-Dateien mit Argumenten in Powershell auszuführen.

Manchmal muss man eine Problemumgehung finden, damit es richtig funktioniert, was einige weitere Anstrengungen und Schmerzen erfordern kann :) abhängig von der Art und Weise, wie die EXE-Datei kompiliert oder zu ihren Erstellern gemacht wurde.

Ich benutze diese einfache, saubere und effektive Methode.

Ich platziere Argumente in einem Array, 1 pro Zeile. Auf diese Weise ist es sehr einfach zu lesen und zu bearbeiten. Dann verwende ich einen einfachen Trick, bei dem alle Argumente in doppelten Anführungszeichen an eine Funktion mit einem einzelnen Parameter übergeben werden. Das macht sie, einschließlich Arrays, zu einer einzigen Zeichenfolge, die ich dann mit PS 'Invoke-Expression' ausführe. Diese Anweisung wurde speziell entwickelt, um eine Zeichenfolge in einen ausführbaren Befehl zu konvertieren. Funktioniert gut:

                    # function with one argument will flatten 
                    # all passed-in entries into 1 single string line
Function Execute($command) {
                    # execute:
    Invoke-Expression $command;
                    # if you have trouble try:
  # Invoke-Expression "& $command";
                    # or if you need also output to a variable
  # Invoke-Expression $command | Tee-Object -Variable cmdOutput;

}

#  ... your main code here ...

               # The name of your executable app
$app = 'my_app.exe';
               # List of arguments:
               #    Notice the type of quotes - important !
               #    Those in single quotes are normal strings, like 'Peter'
$args = 'arg1',
        'arg2',
        $some_variable,
        'arg4',
        "arg5='with quotes'",
        'arg6',
        "arg7 \ with \ $other_variable",
        'etc...';

               # pass all arguments inside double quotes
Execute "$app $args";

Ich hatte den folgenden Code, der perfekt auf meinem Laptop funktionierte:

& $msdeploy `
-source:package="$publishFile" `
-dest:auto,computerName="$server",includeAcls="False",UserName="$username",Password="$password",AuthType="$auth" `
-allowUntrusted  `
-verb:sync  `
-enableRule:DoNotDeleteRule `
-disableLink:AppPoolExtension  `
-disableLink:ContentExtension  `
-disableLink:CertificateExtension  `
-skip:objectName=filePath,absolutePath="^(.*Web\.config|.*Environment\.config)$" `
-setParam:name=`"IIS Web Application Name`",value="$appName"

Als ich dann versuchte, das direkt auf einem Server auszuführen, bekam ich diese Fehler "Unrecognized argument ...etc.... All arguments must begin with "-". "

Nachdem ich alle möglichen Problemumgehungen ausprobiert hatte (kein Erfolg), stellte ich fest, dass Powershell auf dem Server (Windows 2008 R2) Version 3.0 war, während mein Laptop 5.0 hat. (Sie können "$ PSVersionTable" verwenden, um die Version anzuzeigen).

Nach dem Upgrade von Powershell auf die neueste Version funktionierte es wieder.

Cmd kann eine zitierte Exe ausführen, Powershell jedoch nicht. Ich werde mich nur darum kümmern, die Exe selbst zu betreiben, da ich sie nicht habe. Wenn Sie buchstäblich doppelte Anführungszeichen an ein Argument eines externen Befehls senden müssen, ist dies ein weiteres Problem, das an anderer Stelle behandelt wurde.

1) Fügen Sie den exe-Ordner Ihrem Pfad hinzu, möglicherweise in Ihrem $ -Profil

$env:path += ';C:\Program Files\IIS\Microsoft Web Deploy\'
msdeploy

2) die Leerzeichen zurückzählen:

C:\Program` Files\IIS\Microsoft` Web` Deploy\msdeploy.exe

Also bin ich auf ein ähnliches Problem gestoßen und habe es stattdessen folgendermaßen gelöst:

1. Entkomme deinen Anführungszeichen (") mit einem Backtick (`)
2. Umgib deinen neuen Ausdruck mit Anführungszeichen (")
3. Geben Sie mit dem Aufrufoperator (&) den Befehl invoke-expressionfür die neue Zeichenfolge aus

Beispiellösung:

& {Aufrufausdruck "C: \ Programme \ IIS \ Microsoft Web Deploy \ msdeploy.exe -verb: sync -source: dbfullsql =` "Datenquelle = mysource; Integrierte Sicherheit = false; Benutzer-ID = sa; Pwd = sapass !; Database = mydb; `" -dest: dbfullsql = `" Datenquelle =. \ Mydestsource; Integrierte Sicherheit = false; Benutzer-ID = sa; Pwd = sapass !; Database = mydb; `", Computername = 10.10.10.10, Benutzername = Administrator, Passwort = Adminpass` ""}

Für den Namen der ausführbaren Datei kann das Cmdlet new-alias verwendet werden, um zu vermeiden, dass Leerzeichen behandelt werden oder die ausführbare Datei zur $ PATH-Umgebung hinzugefügt werden muss.

PS> new-alias msdeploy "C:\Program Files\IIS\Microsoft Web Deploy\msdeploy.exe"
PS> msdeploy ...

Informationen zum Auflisten oder Ändern von PS-Aliasnamen finden Sie auch unter

PS> get-alias
PS> set-alias

Von Jeffery Hicks Aarticle

Andere Antworten sprechen die Argumente an.