Cómo ejecutar un archivo EXE en PowerShell con parámetros con espacios y comillas

¿Cómo ejecuta el siguiente comando en PowerShell?

C: \ Archivos de programa \ IIS \ Microsoft Web Deploy \ msdeploy.exe -verb: sync -source: dbfullsql = "Fuente de datos = mysource; Seguridad integrada = false; ID de usuario = sa; Pwd = sapass!; Base de datos = mydb;" -dest: dbfullsql = "Fuente de datos =. \ mydestsource; Seguridad integrada = falso; ID de usuario = sa; Pwd = sapass!; Base de datos = mydb;", nombre de equipo = 10.10.10.10, nombre de usuario = administrador, contraseña = adminpass "

Cuando PowerShell ve un comando que comienza con una cadena, solo evalúa la cadena, es decir, generalmente la muestra en la pantalla, por ejemplo:

PS> "Hello World"
Hello World

Si desea que PowerShell interprete la cadena como un nombre de comando, use el operador de llamada (&) de la siguiente manera:

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

Después de eso, probablemente solo necesite citar pares de parámetro / argumento que contengan espacios y / o caracteres de cita. Cuando invocas un archivo EXE como este con argumentos complejos de línea de comandos, generalmente es muy útil tener una herramienta que te muestre cómo PowerShell envía los argumentos al archivo EXE. La Comunidad extensiones de PowerShell tiene una herramienta de este tipo. Se llama echoargs. Simplemente reemplace el archivo EXE con echoargs, dejando todos los argumentos en su lugar, y le mostrará cómo el archivo EXE recibirá los argumentos, por ejemplo:

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>

Usando echoargs puedes experimentar hasta que lo hagas bien, por ejemplo:

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;>

Resulta que estaba intentando demasiado antes mantener las comillas dobles alrededor de la cadena de conexión. Aparentemente eso no es necesario porque incluso cmd.exe los eliminará.

Por cierto, felicitaciones al equipo de PowerShell. Fueron muy útiles para mostrarme el encantamiento específico de comillas simples y dobles para obtener el resultado deseado, si necesita mantener las comillas dobles internas en su lugar. :-) También se dan cuenta de que esta es un área de dolor, pero están motivados por la cantidad de personas afectadas por un problema en particular. Si esta es un área de dolor para usted, vote por favor envío de errores de PowerShell .

Para obtener más información sobre cómo se analiza PowerShell, consulte mi serie de blogs Efectivo de PowerShell , específicamente el artículo 10: "Descripción de los modos de análisis de PowerShell"

ACTUALIZACIÓN 4/4/2012: esta situación se vuelve mucho más fácil de manejar en PowerShell V3. Vea esta publicación de blog para más detalles .

Solo agrega el operador & antes del nombre .exe. Aquí hay un comando para instalar SQL Server Express en modo silencio:

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

& $fileExe  /CONFIGURATIONFILE=$CONFIGURATIONFILE

Tenía espacios tanto en el comando como en los parámetros, y esto es lo que funcionó para mí:

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

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

Básicamente es lo mismo que la respuesta de Akira, pero esto funciona si construyes dinámicamente tus parámetros de comando y los pones en una variable.

Esto funcionó para mí:

& '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')

Simplemente coloque rutas o cadenas de conexión en un elemento de matriz y divida las otras cosas en un elemento de matriz cada una.

Hay muchas otras opciones aquí: https://social.technet.microsoft.com/wiki/contents/articles/7703.powershell-running-executables.aspx

Microsoft debería hacerlo de esta manera más simple y compatible con la sintaxis del símbolo del sistema.

Existen bastantes métodos que puede usar para hacerlo.

Existen otros métodos como usar el Operador de llamada ( & ), el cmdlet Invoke-Expression, etc. Pero se consideran inseguros. Microsoft recomienda usar Start-Process .

Método 1

Un simple ejemplo

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

En tu caso

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"

En este método, se separan todos y cada uno de los parámetros de ArgumentList mediante comas.

Método 2

Ejemplo simple

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

En tu caso

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"

Este método es más fácil ya que permite escribir sus parámetros de una vez.

Tenga en cuenta que en PowerShell para representar la comilla (") en una cadena , debe insertar el acento grave (`) (esta es la tecla sobre la tecla Tab en el teclado de EE. UU.).

El parámetro -NoNewWindow se usa para mostrar el nuevo proceso en la ventana de la consola actual. Por defecto, Windows PowerShell abre una nueva ventana.

Referencias: Powershell / Scripting / Start-Process

Ver esta página: https://slai.github.io/posts/powershell-and-external-commands-done-right/

Resumen usando vshadow como el ejecutable externo:

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

En caso de que alguien se pregunte cómo ejecutar un archivo ejecutable:

.....>. \ file.exe

o

......> full \ path \ to \ file.exe

Pude hacer que mi comando similar funcionara usando el siguiente enfoque:

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

Para su comando (no es que ayude mucho ahora), las cosas se verían así:

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

Los puntos clave son:

• Use comillas alrededor del argumento fuente y elimine las comillas incrustadas alrededor de la cadena de conexión
• Use los nombres de clave alternativos para construir la cadena de conexión SQL que no tienen espacios en ellos. Por ejemplo, use "UID" en lugar de "Id. De usuario", "Servidor" en lugar de "Fuente de datos", "Conexión de confianza" en lugar de "Seguridad integrada", y así sucesivamente. Solo pude hacerlo funcionar una vez que eliminé todos los espacios de la cadena de conexión.

No intenté agregar la parte "nombre del equipo" al final de la línea de comando, pero espero que esta información ayude a otros que la lean ahora a acercarse al resultado deseado.

Nueva cadena de escape en PowerShell V3, citada en Nuevas características del lenguaje V3 :

Reutilización más fácil de las líneas de comando de Cmd.exe

La web está llena de líneas de comando escritas para Cmd.exe. Estas líneas de comando funcionan con bastante frecuencia en PowerShell, pero cuando incluyen ciertos caracteres, por ejemplo, un punto y coma (;), un signo de dólar ($) o llaves, debe realizar algunos cambios, probablemente agregando algunas comillas. Esto parecía ser la fuente de muchos dolores de cabeza menores.

Para ayudar a abordar este escenario, agregamos una nueva forma de "escapar" del análisis de las líneas de comando. Si usa un parámetro mágico -%, detenemos nuestro análisis normal de su línea de comando y cambiamos a algo mucho más simple. No coincidimos con las citas. No nos detenemos en punto y coma. No expandimos las variables de PowerShell. Expandimos las variables de entorno si usa la sintaxis Cmd.exe (por ejemplo,% TEMP%). Aparte de eso, los argumentos hasta el final de la línea (o tubería, si está canalizando) se pasan como están. Aquí hay un ejemplo:

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

Puedes usar:

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"

La clave a tener en cuenta aquí es que FilePath debe estar en la posición 0, de acuerdo con la Guía de ayuda. Para invocar la guía de ayuda para un comando, simplemente escriba Get-Help <Commandlet-name> -Detailed. En este caso, lo es Get-Help Start-Process -Detailed.

Intenté todas las sugerencias pero aún no pude ejecutar msiexec.execon parámetros que contenían espacios. Entonces mi solución terminó usando 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()

Esto funcionó para mí:

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

La clave parece ser que todo el comando está encerrado entre comillas externas, el signo "&" se utiliza para especificar que se está ejecutando otro archivo de comando secundario, y finalmente se escapan las comillas (doble-doble-) alrededor de la ruta / nombre del archivo con espacios en que quería ejecutar en primer lugar.

Esto también es la finalización de la única solución al problema de conexión de MS que -Archivo no devuelve códigos de retorno distintos de cero y -Command es la única alternativa. Pero hasta ahora se pensaba que una limitación de -Command era que no admitía espacios. También actualicé ese elemento de comentarios.

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

Una respuesta alternativa es usar un interruptor de comando codificado Base64 :

powershell -EncodedCommand "QwA6AFwAUAByAG8AZwByAGEAbQAgAEYAaQBsAGUAcwBcAEkASQBTAFwATQBpAGMAcgBvAHMAbwBmAHQAIABXAGUAYgAgAEQAZQBwAGwAbwB5AFwAbQBzAGQAZQBwAGwAbwB5AC4AZQB4AGUAIAAtAHYAZQByAGIAOgBzAHkAbgBjACAALQBzAG8AdQByAGMAZQA6AGQAYgBmAHUAbABsAHMAcQBsAD0AIgBEAGEAdABhACAAUwBvAHUAcgBjAGUAPQBtAHkAcwBvAHUAcgBjAGUAOwBJAG4AdABlAGcAcgBhAHQAZQBkACAAUwBlAGMAdQByAGkAdAB5AD0AZgBhAGwAcwBlADsAVQBzAGUAcgAgAEkARAA9AHMAYQA7AFAAdwBkAD0AcwBhAHAAYQBzAHMAIQA7AEQAYQB0AGEAYgBhAHMAZQA9AG0AeQBkAGIAOwAiACAALQBkAGUAcwB0ADoAZABiAGYAdQBsAGwAcwBxAGwAPQAiAEQAYQB0AGEAIABTAG8AdQByAGMAZQA9AC4AXABtAHkAZABlAHMAdABzAG8AdQByAGMAZQA7AEkAbgB0AGUAZwByAGEAdABlAGQAIABTAGUAYwB1AHIAaQB0AHkAPQBmAGEAbABzAGUAOwBVAHMAZQByACAASQBEAD0AcwBhADsAUAB3AGQAPQBzAGEAcABhAHMAcwAhADsARABhAHQAYQBiAGEAcwBlAD0AbQB5AGQAYgA7ACIALABjAG8AbQBwAHUAdABlAHIAbgBhAG0AZQA9ADEAMAAuADEAMAAuADEAMAAuADEAMAAsAHUAcwBlAHIAbgBhAG0AZQA9AGEAZABtAGkAbgBpAHMAdAByAGEAdABvAHIALABwAGEAcwBzAHcAbwByAGQAPQBhAGQAbQBpAG4AcABhAHMAcwAiAA=="

Cuando lo decodifique, verá que es el fragmento original del OP con todos los argumentos y comillas dobles preservados.

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.

El comando original:

 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"

Se convierte en esto cuando se codifica como Base64:

QwA6AFwAUAByAG8AZwByAGEAbQAgAEYAaQBsAGUAcwBcAEkASQBTAFwATQBpAGMAcgBvAHMAbwBmAHQAIABXAGUAYgAgAEQAZQBwAGwAbwB5AFwAbQBzAGQAZQBwAGwAbwB5AC4AZQB4AGUAIAAtAHYAZQByAGIAOgBzAHkAbgBjACAALQBzAG8AdQByAGMAZQA6AGQAYgBmAHUAbABsAHMAcQBsAD0AIgBEAGEAdABhACAAUwBvAHUAcgBjAGUAPQBtAHkAcwBvAHUAcgBjAGUAOwBJAG4AdABlAGcAcgBhAHQAZQBkACAAUwBlAGMAdQByAGkAdAB5AD0AZgBhAGwAcwBlADsAVQBzAGUAcgAgAEkARAA9AHMAYQA7AFAAdwBkAD0AcwBhAHAAYQBzAHMAIQA7AEQAYQB0AGEAYgBhAHMAZQA9AG0AeQBkAGIAOwAiACAALQBkAGUAcwB0ADoAZABiAGYAdQBsAGwAcwBxAGwAPQAiAEQAYQB0AGEAIABTAG8AdQByAGMAZQA9AC4AXABtAHkAZABlAHMAdABzAG8AdQByAGMAZQA7AEkAbgB0AGUAZwByAGEAdABlAGQAIABTAGUAYwB1AHIAaQB0AHkAPQBmAGEAbABzAGUAOwBVAHMAZQByACAASQBEAD0AcwBhADsAUAB3AGQAPQBzAGEAcABhAHMAcwAhADsARABhAHQAYQBiAGEAcwBlAD0AbQB5AGQAYgA7ACIALABjAG8AbQBwAHUAdABlAHIAbgBhAG0AZQA9ADEAMAAuADEAMAAuADEAMAAuADEAMAAsAHUAcwBlAHIAbgBhAG0AZQA9AGEAZABtAGkAbgBpAHMAdAByAGEAdABvAHIALABwAGEAcwBzAHcAbwByAGQAPQBhAGQAbQBpAG4AcABhAHMAcwAiAA==

y aquí está cómo replicar en casa:

$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

Puede ejecutar archivos exe en powershell de diferentes maneras. Por ejemplo, si desea ejecutar unrar.exe y extraer un archivo .rar, simplemente puede escribir en powershell esto:

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

Pero a veces, esto no funciona, por lo que debe usar el parámetro & como se muestra arriba: por ejemplo, con vboxmanage.exe (una herramienta para administrar máquinas virtuales de virtualbox) debe llamar a los parámetros fuera de la cadena de esta manera, sin comillas:

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

Si desea llamar simplemente un archivo archivado winrar como archivos .exe, también puede descomprimirlo con el cmdlet invoke-command y un parámetro Silent / S (se extraerá en la misma carpeta que donde se ha comprimido).

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

Por lo tanto, hay varias formas de ejecutar archivos .exe con argumentos en powershell.

A veces, uno debe encontrar una solución alternativa para que funcione correctamente, lo que puede requerir un poco más de esfuerzo y dolor :) dependiendo de la forma en que se compiló el archivo .exe o se hizo bi sus creadores.

Utilizo este método simple, limpio y efectivo.

Coloco argumentos en una matriz, 1 por línea. De esta manera es muy fácil de leer y editar. Luego uso un simple truco para pasar todos los argumentos dentro de comillas dobles a una función con 1 parámetro único. Eso los aplana, incluidas las matrices, en una sola cadena, que luego ejecuto usando 'Invoke-Expression' de PS. Esta directiva está específicamente diseñada para convertir una cadena en comando ejecutable. Funciona bien:

                    # 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";

Tenía el siguiente código funcionando perfecto en mi computadora portátil:

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

Luego, cuando intenté ejecutarlo directamente en un servidor, comencé a recibir esos errores "Unrecognized argument ...etc.... All arguments must begin with "-". "

Después de probar todas las soluciones posibles (sin éxito), descubrí que Powershell en el servidor (Windows 2008 R2) era la versión 3.0, mientras que mi computadora portátil tiene 5.0. (puede usar "$ PSVersionTable" para ver la versión).

Después de actualizar Powershell a la última versión, comenzó a funcionar nuevamente.

Cmd puede manejar la ejecución de un exe citado, pero Powershell no. Solo voy a tratar de ejecutar el exe en sí, ya que no lo tengo. Si literalmente necesita enviar comillas dobles a un argumento de un comando externo, ese es otro problema que se ha cubierto en otra parte.

1) agregue la carpeta exe a su ruta, tal vez en su $ profile

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

2) entre comillas los espacios:

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

Entonces, me encontré con un problema similar y decidí resolverlo de esta manera:

1. Escapar de los caracteres de su cita (") con una marca de retroceso (`)
2. Rodea tu nueva expresión con comillas (")
3. Usando el operador de llamada (&), emita el comando invoke-expressionen la nueva cadena

Solución de ejemplo:

& {invoke-expression "C: \ Program Files \ IIS \ Microsoft Web Deploy \ msdeploy.exe -verb: sync -source: dbfullsql =` "Data Source = mysource; Integrated Security = false; User ID = sa; Pwd = sapass !; Base de datos = mydb; `" -dest: dbfullsql = `" Fuente de datos =. \ Mydestsource; Seguridad integrada = falso; ID de usuario = sa; Pwd = sapass!; Base de datos = mydb; `", nombre de computadora = 10.10.10.10, nombre de usuario = administrador, contraseña = adminpass` ""}

Para el nombre del ejecutable, el cmdlet new-alias se puede emplear para evitar tratar con espacios o la necesidad de agregar el ejecutable al entorno $ PATH.

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

Para enumerar o modificar los alias de PS también vea

PS> get-alias
PS> set-alias

Del artículo de Jeffery Hicks

Otras respuestas abordan los argumentos.