Crear scripts de instalación, desinstalación y actualización para aplicaciones VM

Cada versión de la aplicación de máquina virtual necesita un script de instalación y un script de desinstalación, y puede tener un script de actualización. En el portal de Azure, estos scripts son los campos Instalar script, Desinstalar script y Actualizar script. En la API, son las propiedades install, remove y update.

Prerequisites

Los scripts esperan que el paquete se llame appInstall.<extension>, por ejemplo appInstall.msi. Establezca packageFileName en ese nombre cuando cree la versión de la aplicación de máquina virtual. Si no establece este nombre, reemplace appInstall.<extension> en los scripts por el nombre de la aplicación de máquina virtual. Consulte Nomenclatura de archivos para aplicaciones de máquina virtual implementadas.

Scripts para aplicaciones de Windows comunes

Application Format packageFileName Instalar script Valores de desinstalación Actualizar script
7-Zip .exe appInstall.exe appInstall.exe /S $displayNamePattern='7-Zip*'; $fallbackArguments='/S' appInstall.exe /S
7-Zip .msi appInstall.msi msiexec /i appInstall.msi /qn /norestart $displayNamePattern='7-Zip*'; $fallbackArguments='' msiexec /i appInstall.msi /qn /norestart
Google Chrome .msi appInstall.msi msiexec /i appInstall.msi /qn /norestart $displayNamePattern='*Chrome*'; $fallbackArguments='' msiexec /i appInstall.msi /qn /norestart
Python 3.13 .exe appInstall.exe appInstall.exe /quiet /norestart InstallAllUsers=1 PrependPath=1 $displayNamePattern='Python 3.13*'; $fallbackArguments='/quiet /norestart' appInstall.exe /quiet /norestart InstallAllUsers=1 PrependPath=1
PowerShell 7 .msi appInstall.msi msiexec /i appInstall.msi /qn /norestart $displayNamePattern='*Power*Shell*'; $fallbackArguments='' msiexec /i appInstall.msi /qn /norestart
PuTTY .msi appInstall.msi msiexec /i appInstall.msi /qn /norestart $displayNamePattern='*PuTTY release 0.85 (64 bits)*'; $fallbackArguments='' Dejar en blanco.
CLI de Azure .msi appInstall.msi msiexec /i appInstall.msi /qn /norestart $displayNamePattern='*Azure*CLI*'; $fallbackArguments='' msiexec /i appInstall.msi /qn /norestart
Código de Visual Studio .exe (Inno Setup) appInstall.exe appInstall.exe /VERYSILENT /SUPPRESSMSGBOXES /NORESTART /mergetasks=!runcode $displayNamePattern='*Visual*Studio*Code*'; $fallbackArguments='/VERYSILENT /SUPPRESSMSGBOXES /NORESTART' appInstall.exe /VERYSILENT /SUPPRESSMSGBOXES /NORESTART /mergetasks=!runcode
Explorador de Azure Storage .exe (Inno Setup) appInstall.exe appInstall.exe /VERYSILENT /SUPPRESSMSGBOXES /NORESTART /ALLUSERS $displayNamePattern='*Azure Storage*Explorer*'; $fallbackArguments='/VERYSILENT /SUPPRESSMSGBOXES /NORESTART' appInstall.exe /VERYSILENT /SUPPRESSMSGBOXES /NORESTART /ALLUSERS
Adobe Acrobat Reader .exe appInstall.exe appInstall.exe -sfx_nu /sAll /rs /msi $displayNamePattern='*Adobe Acrobat (64-bit)*'; $fallbackArguments='/S' appInstall.exe -sfx_nu /sAll /rs /msi
SQL Server Management Studio 22 .exe appInstall.exe appInstall.exe --quiet --wait --campaign winget $displayNamePattern='*SQL*Server*Management*Studio 22*'; $fallbackArguments='/S' appInstall.exe update --quiet --wait --campaign winget
Cinc Client .msi appInstall.msi msiexec /i appInstall.msi /qn /norestart $displayNamePattern='Cinc Client*'; $fallbackArguments='' msiexec /i appInstall.msi /qn /norestart
Automox Agent .msi appInstall.msi msiexec /i appInstall.msi /qn /norestart ACCESSKEY=<automox-access-key> $displayNamePattern='Agente Automox*'; $fallbackArguments='' msiexec /i appInstall.msi /qn /norestart ACCESSKEY=<automox-access-key>

Para publicar una aplicación de la tabla anterior:

  1. Descargue el instalador en el formato indicado. Usa una versión específica, no un vínculo a la versión más reciente.
  2. Cargue el instalador en su cuenta de almacenamiento.
  3. Cree la versión de la aplicación de máquina virtual con el packageFileName indicado.
  4. Configure los scripts de instalación y actualización según los comandos de la tabla. Si el script de actualización es Dejar en blanco., déjelo vacío.
  5. Establezca el script de desinstalación en el script de desinstalación de Windows y sustituya $displayNamePattern='<DISPLAY-NAME-PATTERN>'; $fallbackArguments='' por los valores de desinstalación de la tabla.
  6. Pruebe la instalación, actualización y desinstalación en la máquina virtual de prueba. Consulte Validar antes de publicar.

Notes:

  • Agente de Automox: Reemplace <automox-access-key> por su clave de acceso de la consola de Automox. Sin una clave válida, el agente se instala pero no aparece en la consola.
  • Cinc Client y agente de Automox: Estos agentes pueden actualizarse a sí mismos a través de la consola del proveedor. Para administrar la versión desde Azure, publique una nueva versión de la aplicación.

Note

Cualquier persona con permiso de lectura en la galería puede ver los scripts, incluidas las claves de acceso. Restrinja el acceso de lectura de la galería si un valor es confidencial.

Importante

Los formatos del instalador, los argumentos silenciosos y los códigos de retorno pueden cambiar entre versiones. Verifíquelos con el editor de la versión que descargue.

Script de desinstalación de Windows

Este script funciona para cualquier aplicación que se registre en el registro de desinstalación de Windows. Ejecuta el comando de desinstalación registrado, tiene éxito si la aplicación ya está ausente y comprueba la eliminación. Establezca los dos valores al principio:

Si no reemplaza <DISPLAY-NAME-PATTERN>, el script finaliza con el código 87.

powershell -NoProfile -ExecutionPolicy Bypass -Command "$ErrorActionPreference='SilentlyContinue'; $displayNamePattern='<DISPLAY-NAME-PATTERN>'; $fallbackArguments=''; if($displayNamePattern -like '*DISPLAY-NAME-PATTERN*'){ Write-Output 'UNINSTALL: set displayNamePattern before publishing'; exit 87 }; $keys=@('HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*','HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*'); $apps=@(Get-ItemProperty $keys | Where-Object { $_.DisplayName -like $displayNamePattern -and $_.SystemComponent -ne 1 }); if($apps.Count -eq 0){ Write-Output 'UNINSTALL: no matching registry entry; nothing to do'; exit 0 }; $code=0; foreach($a in $apps){ if(-not (Get-ItemProperty $a.PSPath)){ continue }; $c=$a.QuietUninstallString; if(-not $c){ $c=$a.UninstallString; if(-not $c){ continue }; $g=[regex]::Match($c,'\{[0-9A-Fa-f-]+\}').Value; if($c -match 'msiexec' -and $g){ $c='msiexec.exe /x '+$g+' /qn /norestart' } elseif($fallbackArguments){ $c=$c+' '+$fallbackArguments } else { Write-Output ('UNINSTALL: set fallbackArguments for '+$a.DisplayName); exit 87 } }; $p=Start-Process cmd.exe -ArgumentList '/c',$c -NoNewWindow -PassThru; $null=$p.Handle; if($p.WaitForExit(600000)){ $rc=$p.ExitCode } else { try{ $p.Kill() }catch{}; $rc=1460 }; $gone=-not (Get-ItemProperty $a.PSPath); Write-Output ('UNINSTALL: '+$a.DisplayName+' exit='+$rc+' removed='+$gone); if(-not $gone){ if($rc -eq 0){ $code=1 } else { $code=$rc } } }; exit $code"

Scripts para aplicaciones comunes de Linux

Busca tu aplicación y distribución. Las combinaciones que no aparecen en la lista no se probaron.

Application Format Distribuciones packageFileName Instalar script Script de desinstalación Actualizar script Dependencias
Cinc Client .deb Ubuntu, Debian appInstall.deb export DEBIAN_FRONTEND=noninteractive; apt-get install -y -o DPkg::Lock::Timeout=600 ./appInstall.deb || { apt-get update -o DPkg::Lock::Timeout=600 && apt-get install -y -o DPkg::Lock::Timeout=600 ./appInstall.deb; } if [ "$(dpkg-query -W -f='${db:Status-Status}' cinc 2>/dev/null)" = installed ]; then DEBIAN_FRONTEND=noninteractive apt-get purge -y -o DPkg::Lock::Timeout=600 cinc; else echo 'cinc not installed'; fi Igual que en la instalación. Descargado por apt-get, por lo que la máquina virtual necesita acceso al repositorio. Para las instalaciones sin conexión, use .tar.gz.
Cinc Client .rpm RHEL, SLES appInstall.rpm rpm -Uvh --replacepkgs appInstall.rpm if rpm -q cinc >/dev/null 2>&1; then rpm -e cinc; else echo 'cinc not installed'; fi Igual que en la instalación. Ya debe estar en la máquina virtual. De lo contrario, use .tar.gz.
PowerShell 7 .deb Ubuntu, Debian appInstall.deb export DEBIAN_FRONTEND=noninteractive; apt-get install -y -o DPkg::Lock::Timeout=600 ./appInstall.deb || { apt-get update -o DPkg::Lock::Timeout=600 && apt-get install -y -o DPkg::Lock::Timeout=600 ./appInstall.deb; } if [ "$(dpkg-query -W -f='${db:Status-Status}' powershell 2>/dev/null)" = installed ]; then DEBIAN_FRONTEND=noninteractive apt-get purge -y -o DPkg::Lock::Timeout=600 powershell; else echo 'powershell not installed'; fi Igual que en la instalación. Descargado por apt-get, por lo que la máquina virtual necesita acceso al repositorio. Para las instalaciones sin conexión, use .tar.gz.
PowerShell 7 .rpm RHEL, Azure Linux appInstall.rpm rpm -Uvh --replacepkgs appInstall.rpm if rpm -q powershell >/dev/null 2>&1; then rpm -e powershell; else echo 'powershell no está instalado'; fi Igual que en la instalación. Ya debe estar en la máquina virtual. De lo contrario, use .tar.gz.
PowerShell 7 .tar.gz (paquete deb) Ubuntu, Debian appInstall.tar.gz mkdir -p pkgs && tar -xzf appInstall.tar.gz -C pkgs && cd pkgs && { n=app.deb; for f in *.deb; do [ "$f" = app.deb ] && continue; i=$(dpkg-query -W -f='${db:Status-Status} ${Version}' "$(dpkg-deb -f "$f" Package)" 2>/dev/null); if [ "${i%% *}" != installed ] || dpkg --compare-versions "${i#* }" lt "$(dpkg-deb -f "$f" Version)"; then n="$n $f"; fi; done; DEBIAN_FRONTEND=noninteractive dpkg -i $n; } if [ "$(dpkg-query -W -f='${db:Status-Status}' powershell 2>/dev/null)" = installed ]; then DEBIAN_FRONTEND=noninteractive apt-get purge -y -o DPkg::Lock::Timeout=600 powershell; else echo 'powershell not installed'; fi Igual que en la instalación. Agrupado. La máquina virtual no necesita acceso al repositorio. Consulta Crear un paquete de dependencias.
PowerShell 7 .tar.gz (paquete rpm) RHEL, Azure Linux appInstall.tar.gz mkdir -p pkgs && tar -xzf appInstall.tar.gz -C pkgs && cd pkgs && { n=app.rpm; for f in *.rpm; do [ "$f" = app.rpm ] && continue; if rpm -U --test --nodeps "$f" >/dev/null 2>&1; then n="$n $f"; fi; done; rpm -Uvh --replacepkgs $n; } if rpm -q powershell >/dev/null 2>&1; then rpm -e powershell; else echo 'powershell no está instalado'; fi Igual que en la instalación. Incluido. La máquina virtual no necesita acceso al repositorio. Consulta Crear un paquete de dependencias.
CLI de Azure .deb Ubuntu, Debian appInstall.deb export DEBIAN_FRONTEND=noninteractive; apt-get install -y -o DPkg::Lock::Timeout=600 ./appInstall.deb || { apt-get update -o DPkg::Lock::Timeout=600 && apt-get install -y -o DPkg::Lock::Timeout=600 ./appInstall.deb; } if [ "$(dpkg-query -W -f='${db:Status-Status}' azure-cli 2>/dev/null)" = installed ]; then DEBIAN_FRONTEND=noninteractive apt-get purge -y -o DPkg::Lock::Timeout=600 azure-cli; else echo 'azure-cli not installed'; fi Igual que en la instalación. Descargado por apt-get, por lo que la máquina virtual necesita acceso al repositorio. Para las instalaciones sin conexión, use .tar.gz.
CLI de Azure .rpm RHEL, Azure Linux appInstall.rpm rpm -Uvh --replacepkgs appInstall.rpm if rpm -q azure-cli >/dev/null 2>&1; then rpm -e azure-cli; else echo 'azure-cli no está instalado'; fi Igual que en la instalación. Ya debe estar en la máquina virtual. De lo contrario, use .tar.gz.
CLI de Azure .tar.gz (paquete rpm) RHEL (Red Hat Enterprise Linux) appInstall.tar.gz mkdir -p pkgs && tar -xzf appInstall.tar.gz -C pkgs && cd pkgs && { n=app.rpm; for f in *.rpm; do [ "$f" = app.rpm ] && continue; if rpm -U --test --nodeps "$f" >/dev/null 2>&1; then n="$n $f"; fi; done; rpm -Uvh --replacepkgs $n; } if rpm -q azure-cli >/dev/null 2>&1; then rpm -e azure-cli; else echo 'azure-cli no está instalado'; fi Igual que en la instalación. Agrupado. La máquina virtual no necesita acceso al repositorio. Consulta Crear un paquete de dependencias.
Agente de Automox .deb Ubuntu, Debian appInstall.deb export DEBIAN_FRONTEND=noninteractive; apt-get install -y -o DPkg::Lock::Timeout=600 ./appInstall.deb || { apt-get update -o DPkg::Lock::Timeout=600 && apt-get install -y -o DPkg::Lock::Timeout=600 ./appInstall.deb; } && /opt/amagent/amagent --setkey <automox-access-key> && systemctl restart amagent if [ "$(dpkg-query -W -f='${db:Status-Status}' amagent 2>/dev/null)" = installed ]; then /opt/amagent/amagent --deregister; DEBIAN_FRONTEND=noninteractive apt-get purge -y -o DPkg::Lock::Timeout=600 amagent; else echo 'amagent not installed'; fi Igual que en la instalación. Descargado por apt-get, por lo que la máquina virtual necesita acceso al repositorio. Para las instalaciones sin conexión, use .tar.gz.
Automox Agent .rpm RHEL, SLES appInstall.rpm rpm -Uvh --replacepkgs appInstall.rpm && /opt/amagent/amagent --setkey <automox-access-key> && systemctl restart amagent if rpm -q amagent >/dev/null 2>&1; then /opt/amagent/amagent --deregister; rpm -e amagent; else echo 'amagent not installed'; fi Igual que en la instalación. Ya debe estar en la máquina virtual. De lo contrario, usa .tar.gz.
Agente de Automox .tar.gz (paquete deb) Ubuntu, Debian appInstall.tar.gz mkdir -p pkgs && tar -xzf appInstall.tar.gz -C pkgs && cd pkgs && { n=app.deb; for f in *.deb; do [ "$f" = app.deb ] && continue; i=$(dpkg-query -W -f='${db:Status-Status} ${Version}' "$(dpkg-deb -f "$f" Package)" 2>/dev/null); if [ "${i%% *}" != installed ] || dpkg --compare-versions "${i#* }" lt "$(dpkg-deb -f "$f" Version)"; then n="$n $f"; fi; done; DEBIAN_FRONTEND=noninteractive dpkg -i $n && /opt/amagent/amagent --setkey <automox-access-key> && systemctl restart amagent; } if [ "$(dpkg-query -W -f='${db:Status-Status}' amagent 2>/dev/null)" = installed ]; then /opt/amagent/amagent --deregister; DEBIAN_FRONTEND=noninteractive apt-get purge -y -o DPkg::Lock::Timeout=600 amagent; else echo 'amagent not installed'; fi Igual que en la instalación. Agrupado. La máquina virtual no necesita acceso al repositorio. Consulta Crear un paquete de dependencias.
Automox Agent .tar.gz (paquete rpm) RHEL, SLES appInstall.tar.gz [ -L /etc/init.d ] || rmdir /etc/init.d 2>/dev/null; mkdir -p pkgs && tar -xzf appInstall.tar.gz -C pkgs && cd pkgs && { n=app.rpm; for f in *.rpm; do [ "$f" = app.rpm ] && continue; if rpm -U --test --nodeps "$f" >/dev/null 2>&1; then n="$n $f"; fi; done; rpm -Uvh --replacepkgs $n && /opt/amagent/amagent --setkey <automox-access-key> && systemctl restart amagent; } if rpm -q amagent >/dev/null 2>&1; then /opt/amagent/amagent --deregister; rpm -e amagent; else echo 'amagent not installed'; fi Igual que en la instalación. Agrupado. La máquina virtual no necesita acceso al repositorio. Consulta Crear un paquete de dependencias.
Google Chrome .deb Ubuntu, Debian appInstall.deb export DEBIAN_FRONTEND=noninteractive; apt-get install -y -o DPkg::Lock::Timeout=600 ./appInstall.deb || { apt-get update -o DPkg::Lock::Timeout=600 && apt-get install -y -o DPkg::Lock::Timeout=600 ./appInstall.deb; } if [ "$(dpkg-query -W -f='${db:Status-Status}' google-chrome-stable 2>/dev/null)" = installed ]; then DEBIAN_FRONTEND=noninteractive apt-get purge -y -o DPkg::Lock::Timeout=600 google-chrome-stable; else echo 'google-chrome-stable not installed'; fi Igual que en la instalación. Descargado por apt-get, por lo que la máquina virtual necesita acceso al repositorio. Para las instalaciones sin conexión, use .tar.gz.
Google Chrome .rpm RHEL, SLES appInstall.rpm rpm -Uvh --replacepkgs appInstall.rpm if rpm -q google-chrome-stable >/dev/null 2>&1; then rpm -e google-chrome-stable; else echo 'google-chrome-stable not installed'; fi Igual que en la instalación. Ya debe estar en la máquina virtual. De lo contrario, use .tar.gz.
Google Chrome .tar.gz (paquete deb) Ubuntu, Debian appInstall.tar.gz mkdir -p pkgs && tar -xzf appInstall.tar.gz -C pkgs && cd pkgs && { n=app.deb; for f in *.deb; do [ "$f" = app.deb ] && continue; i=$(dpkg-query -W -f='${db:Status-Status} ${Version}' "$(dpkg-deb -f "$f" Package)" 2>/dev/null); if [ "${i%% *}" != installed ] || dpkg --compare-versions "${i#* }" lt "$(dpkg-deb -f "$f" Version)"; then n="$n $f"; fi; done; DEBIAN_FRONTEND=noninteractive dpkg -i $n; } if [ "$(dpkg-query -W -f='${db:Status-Status}' google-chrome-stable 2>/dev/null)" = installed ]; then DEBIAN_FRONTEND=noninteractive apt-get purge -y -o DPkg::Lock::Timeout=600 google-chrome-stable; else echo 'google-chrome-stable not installed'; fi Igual que en la instalación. Incluido. La máquina virtual no necesita acceso al repositorio. Consulte Crear un paquete de dependencias.
Google Chrome .tar.gz (paquete rpm) RHEL, SLES appInstall.tar.gz mkdir -p pkgs && tar -xzf appInstall.tar.gz -C pkgs && cd pkgs && { n=app.rpm; for f in *.rpm; do [ "$f" = app.rpm ] && continue; if rpm -U --test --nodeps "$f" >/dev/null 2>&1; then n="$n $f"; fi; done; rpm -Uvh --replacepkgs $n; } if rpm -q google-chrome-stable >/dev/null 2>&1; then rpm -e google-chrome-stable; else echo 'google-chrome-stable not installed'; fi Igual que en la instalación. Agrupado. La máquina virtual no necesita acceso al repositorio. Consulta Crear un paquete de dependencias.
Código de Visual Studio .deb Ubuntu, Debian appInstall.deb export DEBIAN_FRONTEND=noninteractive; apt-get install -y -o DPkg::Lock::Timeout=600 ./appInstall.deb || { apt-get update -o DPkg::Lock::Timeout=600 && apt-get install -y -o DPkg::Lock::Timeout=600 ./appInstall.deb; } if [ "$(dpkg-query -W -f='${db:Status-Status}' code 2>/dev/null)" = installed ]; then DEBIAN_FRONTEND=noninteractive apt-get purge -y -o DPkg::Lock::Timeout=600 code; else echo 'code not installed'; fi Igual que en la instalación. Descargado por apt-get, por lo que la máquina virtual necesita acceso al repositorio. Para las instalaciones sin conexión, use .tar.gz.
Código de Visual Studio .rpm RHEL, SLES appInstall.rpm rpm -Uvh --replacepkgs appInstall.rpm if rpm -q code >/dev/null 2>&1; then rpm -e code; else echo 'code not installed'; fi Igual que en la instalación. Ya debe estar en la máquina virtual. De lo contrario, utilice .tar.gz.
Código de Visual Studio .tar.gz (paquete deb) Ubuntu, Debian appInstall.tar.gz mkdir -p pkgs && tar -xzf appInstall.tar.gz -C pkgs && cd pkgs && { n=app.deb; for f in *.deb; do [ "$f" = app.deb ] && continue; i=$(dpkg-query -W -f='${db:Status-Status} ${Version}' "$(dpkg-deb -f "$f" Package)" 2>/dev/null); if [ "${i%% *}" != installed ] || dpkg --compare-versions "${i#* }" lt "$(dpkg-deb -f "$f" Version)"; then n="$n $f"; fi; done; DEBIAN_FRONTEND=noninteractive dpkg -i $n; } if [ "$(dpkg-query -W -f='${db:Status-Status}' code 2>/dev/null)" = installed ]; then DEBIAN_FRONTEND=noninteractive apt-get purge -y -o DPkg::Lock::Timeout=600 code; else echo 'code not installed'; fi Igual que en la instalación. Agrupado. La máquina virtual no necesita acceso al repositorio. Consulta Crear un paquete de dependencias.
Código de Visual Studio .tar.gz (paquete rpm) RHEL, SLES appInstall.tar.gz mkdir -p pkgs && tar -xzf appInstall.tar.gz -C pkgs && cd pkgs && { n=app.rpm; for f in *.rpm; do [ "$f" = app.rpm ] && continue; if rpm -U --test --nodeps "$f" >/dev/null 2>&1; then n="$n $f"; fi; done; rpm -Uvh --replacepkgs $n; } if rpm -q code >/dev/null 2>&1; then rpm -e code; else echo 'code no está instalado'; fi Igual que en la instalación. Agrupado. La máquina virtual no necesita acceso al repositorio. Consulte Compilación de una agrupación de dependencias.

Para publicar una aplicación desde la tabla:

  1. Elija una fila. Para máquinas virtuales sin acceso al repositorio, o cuando las dependencias .rpm no se encuentran en la máquina virtual, utiliza una fila .tar.gz.
  2. Descarga el paquete del proveedor correspondiente a tu distribución. Usa una versión específica, no un vínculo a la versión más reciente.
  3. Para una entrada de .tar.gz, cree un paquete de dependencias.
  4. Suba el paquete a su cuenta de almacenamiento.
  5. Cree la versión de la aplicación de máquina virtual con el packageFileName indicado.
  6. Configura los scripts de instalación, desinstalación y actualización con los comandos de la tabla.
  7. Pruebe la instalación, actualización y desinstalación en la máquina virtual de prueba. Consulte Validar antes de publicar.

Los scripts se ejecutan como root en el directorio de descarga del paquete.

Notes:

  • Agente de Automox: Sustituya <automox-access-key> por su clave de acceso de la consola de Automox. La clave es un UUID. El script de desinstalación da de baja primero el agente.
  • Cinc Client: no se admite Azure Linux 3, ya que no proporciona libcrypt.so.2. La desinstalación deja la configuración en /etc/cinc.
  • Google Chrome y Visual Studio Code: Las imágenes de RHEL de Azure Marketplace tienen un volumen raíz pequeño. Confirme el espacio libre para /opt y /usr/share.
  • Todas las aplicaciones: La desinstalación se realiza correctamente si la aplicación no está presente y deja las dependencias en su sitio. Probado en imágenes Azure Marketplace de Ubuntu 24.04 LTS, Debian 12, RHEL 9, SLES 15 SP6 y Azure Linux 3.

Note

Cualquier persona con permiso de lectura en la galería puede ver los scripts, incluidas las claves de acceso. Restrinja el acceso de lectura de la galería si un valor es confidencial.

Importante

Los nombres de paquete, las dependencias y las distribuciones admitidas pueden cambiar entre versiones. Verifíquelos con el editor de la versión que descargue.

Crea un paquete de dependencias

Un bundle es un archivo .tar.gz que contiene el paquete del proveedor y todas sus dependencias, por lo que la máquina virtual no necesita acceso al repositorio. El script de instalación de .tar.gz instala solo las dependencias agrupadas que faltan o que son más antiguas en la máquina virtual.

  1. Cree una máquina virtual a partir de una imagen limpia de la distribución y versión de destino, como RHEL 9. Una imagen limpia garantiza que la agrupación incluya todas las dependencias. La máquina virtual necesita acceso al repositorio.
  2. Copie el paquete del fabricante y el script de compilación en la VM y ejecute el script como root:
    • Ubuntu y Debian: sh build-deb-bundle.sh <vendor-package.deb>
    • RHEL, SLES, y Azure Linux: sh build-rpm-bundle.sh <vendor-package.rpm>
  3. Sube el archivo appInstall.tar.gz resultante como paquete de la aplicación.

build-deb-bundle.sh:

#!/bin/sh
# build-deb-bundle.sh <vendor-package.deb>
# Run on a clean VM of the target distribution. Writes appInstall.tar.gz to the
# current directory: the vendor package as app.deb plus every dependency.
set -e
app=$(readlink -f "$1")
pkg=$(dpkg-deb -f "$app" Package)
work=$(mktemp -d)
apt-get update
apt-get clean
DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends --download-only "$app"
for f in /var/cache/apt/archives/*.deb; do
  [ -e "$f" ] || continue
  if [ "$(dpkg-deb -f "$f" Package)" != "$pkg" ]; then cp "$f" "$work/"; fi
done
cp "$app" "$work/app.deb"
tar -czf appInstall.tar.gz -C "$work" .
rm -rf "$work"
tar -tzf appInstall.tar.gz

build-rpm-bundle.sh:

#!/bin/sh
# build-rpm-bundle.sh <vendor-package.rpm>
# Run on a clean VM of the target distribution. Writes appInstall.tar.gz to the
# current directory: the vendor package as app.rpm plus every dependency.
set -e
app=$(readlink -f "$1")
pkg=$(rpm -qp --qf '%{NAME}' "$app" 2>/dev/null)
work=$(mktemp -d)
if command -v dnf >/dev/null 2>&1; then
  # Fresh RHEL images ship with no imported keys, and dnf's automatic import fails.
  # Boot-time jobs can hold the RPM lock briefly, so retry the import.
  k=/etc/pki/rpm-gpg/RPM-GPG-KEY-redhat-release
  if [ -f "$k" ]; then i=0; until rpm --import "$k"; do i=$((i+1)); [ "$i" -lt 30 ] || exit 1; sleep 10; done; fi
  dnf install -y --downloadonly --setopt=install_weak_deps=False --downloaddir="$work" "$app"
elif command -v tdnf >/dev/null 2>&1; then
  tdnf install -y --downloadonly --downloaddir="$work" "$app"
elif command -v zypper >/dev/null 2>&1; then
  mkdir -p "$work/cache"
  zypper --non-interactive --no-gpg-checks --pkg-cache-dir "$work/cache" install --download-only --no-recommends --allow-unsigned-rpm "$app"
  find "$work/cache" -name '*.rpm' -exec mv {} "$work/" \;
  rm -rf "$work/cache"
else
  echo "dnf, tdnf, or zypper is required" >&2
  exit 1
fi
for f in "$work"/*.rpm; do
  [ -e "$f" ] || continue
  if [ "$(rpm -qp --qf '%{NAME}' "$f" 2>/dev/null)" = "$pkg" ]; then rm -f "$f"; fi
done
cp "$app" "$work/app.rpm"
tar -czf appInstall.tar.gz -C "$work" .
rm -rf "$work"
tar -tzf appInstall.tar.gz

Creación de scripts para otras aplicaciones

Si la aplicación no aparece en la lista, cree sus scripts mediante esta guía.

Requisitos del script

Cada script debe:

  • Instale desde el paquete descargado. Para incluir dependencias, cree un paquete de dependencias.
  • Ejecute silenciosamente, sin avisos.
  • Espere a que finalice el instalador y sus procesos secundarios.
  • No reinicies la máquina virtual. Utiliza scriptBehaviorAfterReboot para controlar el comportamiento tras el reinicio.
  • Devuelve 0 si se ejecuta correctamente y un valor distinto de cero en caso de error. Trate otros códigos como correctos solo si el publicador los documenta.
  • No exceda los 4.096 caracteres. Coloque una lógica más larga en un script dentro de un paquete ZIP o TAR.
  • Asegúrate de que se pueda ejecutar de nuevo.

Azure ejecuta cada script en el directorio de descarga del paquete. Windows usa cmd.exe y Linux usa /bin/bash.

Crear un script de instalación

Utiliza los argumentos de instalación desatendida del editor.

Instalar un EXE en Windows

Los instaladores EXE como InstallShield, Inno Setup, NSIS y Burn usan diferentes argumentos silenciosos, por lo que /S, /silenty /quiet no son intercambiables. Elimina cualquier marcador de posición que el instalador no necesite. PowerShell espera al instalador y devuelve su código de salida.

powershell.exe -NoProfile -ExecutionPolicy Bypass -Command "$process=Start-Process -FilePath '.\appInstall.exe' -ArgumentList '<silent-install-arguments>','<no-restart-argument>' -Wait -PassThru; exit $process.ExitCode"

Instalar un MSI en Windows

/qnoculta la interfaz de usuario, /norestart evita un reinicio y start /wait espera al Instalador de Windows. Agregue las propiedades MSI después de /norestart.

start /wait msiexec.exe /i ".\appInstall.msi" /qn /norestart

Instalación de un paquete ZIP o PowerShell en Windows

Incluye los archivos de la aplicación y un install.ps1 de instalación desatendida en el archivo ZIP, con la misma estructura en todas las versiones. install.ps1Debe copiar la aplicación fuera del directorio de descarga, ya que Azure puede eliminar ese directorio.

powershell.exe -NoProfile -ExecutionPolicy Bypass -Command "$ErrorActionPreference='Stop'; Remove-Item '.\payload' -Recurse -Force -ErrorAction SilentlyContinue; Expand-Archive -LiteralPath '.\appInstall.zip' -DestinationPath '.\payload' -Force; & '.\payload\install.ps1'; exit $LASTEXITCODE"

Para un paquete de .ps1, use un parámetro Action para que un solo script gestione las tres operaciones.

powershell.exe -NoProfile -ExecutionPolicy Bypass -File ".\appInstall.ps1" -Action Install

Instalación de un paquete DEB en Debian o Ubuntu

dpkg no descarga dependencias, por lo que la máquina virtual ya debe tenerlas. Para incluirlos, cree un paquete de dependencias.

sudo env DEBIAN_FRONTEND=noninteractive dpkg --install "./appInstall.deb"

Instalar un paquete RPM en RHEL, CentOS o SUSE

--upgrade instala o actualiza el paquete y --replacepkgs hace que los reintentos sean seguros. La máquina virtual ya debe tener dependencias. Para incluirlos, cree una agrupación de dependencias.

sudo rpm --upgrade --replacepkgs "./appInstall.rpm"

Instalar un paquete TAR o script de shell en Linux

Incluye los archivos de la aplicación y un install.sh de instalación desatendida, que debe copiar la aplicación fuera del directorio de descargas. Usa -xzf para .tar.gz y -xf para .tar.

rm -rf ./payload && mkdir ./payload && tar -xzf "./appInstall.tar.gz" -C ./payload && chmod +x ./payload/install.sh && sudo ./payload/install.sh

Para un paquete de .sh, acepte un argumento de acción. Utilice sudo solo para instalaciones en todo el sistema.

chmod +x "./appInstall.sh" && sudo "./appInstall.sh" install

Crear un script de desinstalación

Junto con los requisitos del script, un script de desinstalación debe:

  • Elimine solo la aplicación de destino, incluidos sus archivos fuera del directorio de descarga.
  • Devuelve 0 si la aplicación ya está ausente.
  • Mantenga las dependencias compartidas y los datos de los clientes, a menos que la directiva de eliminación del editor indique lo contrario.

Desinstalar un EXE en Windows

Utilice el script de desinstalación de Windows. Para encontrar sus valores, consulta Buscar el nombre para mostrar de una aplicación de Windows.

Desinstalar un MSI en Windows

Utiliza el script de desinstalación de Windows. Es seguro volver a intentarlo, controla los códigos de producto que cambian entre versiones y comprueba la eliminación.

Si solo las aplicaciones de máquina virtual instalan y desinstalan el MSI, en la misma versión, puedes utilizar el archivo del paquete o el código del producto instalado en su lugar:

start /wait msiexec.exe /x ".\appInstall.msi" /qn /norestart
start /wait msiexec.exe /x "{PRODUCT-CODE}" /qn /norestart

Importante

msiexec.exe devuelve 1605 si el producto ya está ausente. Compruebe primero o trate 1605 como éxito después de confirmar la eliminación.

Desinstalación de un paquete ZIP o PowerShell en Windows

Incluye un uninstall.ps1 idempotente que elimine únicamente los archivos de la aplicación.

powershell.exe -NoProfile -ExecutionPolicy Bypass -Command "$ErrorActionPreference='Stop'; Remove-Item '.\payload' -Recurse -Force -ErrorAction SilentlyContinue; Expand-Archive -LiteralPath '.\appInstall.zip' -DestinationPath '.\payload' -Force; & '.\payload\uninstall.ps1'; exit $LASTEXITCODE"
powershell.exe -NoProfile -ExecutionPolicy Bypass -File ".\appInstall.ps1" -Action Uninstall

Desinstalar un paquete DEB en Debian o Ubuntu

Este script lee el nombre del paquete del archivo .deb y quita el paquete si está instalado.

packageName="$(dpkg-deb --field "./appInstall.deb" Package)" && status="$(dpkg-query -W -f='${db:Status-Status}' "$packageName" 2>/dev/null || true)" && if [ "$status" = "installed" ]; then sudo dpkg --remove "$packageName"; fi

Desinstalar un paquete RPM en RHEL, CentOS o SUSE

Este script lee el nombre del paquete del archivo .rpm y quita el paquete si está instalado.

packageName="$(rpm -qp --queryformat '%{NAME}' "./appInstall.rpm")" && if rpm -q "$packageName" >/dev/null 2>&1; then sudo rpm --erase "$packageName"; fi

Desinstalar un paquete TAR o de script de shell en Linux

Incluya una operación idempotente uninstall.sh que devuelva 0 si la aplicación ya está ausente.

rm -rf ./payload && mkdir ./payload && tar -xzf "./appInstall.tar.gz" -C ./payload && chmod +x ./payload/uninstall.sh && sudo ./payload/uninstall.sh
chmod +x "./appInstall.sh" && sudo "./appInstall.sh" uninstall

Buscar el nombre para mostrar de una aplicación de Windows

El script de desinstalación de Windows necesita un identificador $displayNamePattern que coincida solo con tu aplicación. Las aplicaciones de la tabla de Windows ya cuentan con uno.

Instale el paquete exacto que planea publicar en una máquina virtual de prueba y, a continuación, ejecute:

az vm run-command invoke \
  --resource-group <resource-group> \
  --name <vm-name> \
  --command-id RunPowerShellScript \
  --scripts 'Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*","HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*" -ErrorAction SilentlyContinue | Where-Object { $_.DisplayName -and $_.SystemComponent -ne 1 } | Sort-Object DisplayName | Format-List DisplayName, QuietUninstallString, UninstallString'

Mantenga las comillas externas simples para que el shell local no expanda $_.

Busque la aplicación en el resultado. Si no está seguro de qué entrada es, compare la salida antes y después de instalar el paquete. Mantenga el nombre del producto en el patrón y reemplace las partes que cambian entre versiones por un carácter comodín:

Nombre para mostrar registrado Patrón a utilizar
7-Zip 26.03 (x64 edition) 7-Zip*
Python 3.13.15 (64-bit) Python 3.13*
Contoso Agent 4.2 Contoso Agent*

Inicie el patrón con el nombre del producto. Por ejemplo, Python 3.13* excluye Python Launcher, pero *Python* coincide con ambos. Para confirmar el patrón, añade -and $_.DisplayName -like '<your-pattern>' al filtro Where-Object y comprueba que solo se muestre tu aplicación.

Crear un script de actualización

El script de actualización es opcional. Si está en blanco, VM Applications ejecuta el script de desinstalación de la versión anterior y, a continuación, el script de instalación de la nueva versión. Déjalo en blanco si el instalador no dispone de una actualización in situ probada.

Un script de actualización debe conservar la configuración y los datos de los clientes, eliminar los archivos obsoletos y actualizar desde todas las versiones anteriores que admitas.

Actualizar un EXE en Windows

Utiliza los argumentos de actualización del editor. Algunos instaladores realizan la actualización utilizando sus argumentos de instalación habituales.

powershell.exe -NoProfile -ExecutionPolicy Bypass -Command "$process=Start-Process -FilePath '.\appInstall.exe' -ArgumentList '<silent-update-arguments>','<no-restart-argument>' -Wait -PassThru; exit $process.ExitCode"

Actualizar un MSI en Windows

Use este comando solo si los metadatos de actualización del nuevo MSI abarcan las versiones instaladas. Pruebe las actualizaciones mayores y menores.

start /wait msiexec.exe /i ".\appInstall.msi" /qn /norestart

Actualizar un paquete ZIP o PowerShell en Windows

Incluya un update.ps1 que mantenga la configuración, reemplace los archivos modificados y quite los obsoletos.

powershell.exe -NoProfile -ExecutionPolicy Bypass -Command "$ErrorActionPreference='Stop'; Remove-Item '.\payload' -Recurse -Force -ErrorAction SilentlyContinue; Expand-Archive -LiteralPath '.\appInstall.zip' -DestinationPath '.\payload' -Force; & '.\payload\update.ps1'; exit $LASTEXITCODE"
powershell.exe -NoProfile -ExecutionPolicy Bypass -File ".\appInstall.ps1" -Action Update

Actualizar un paquete DEB en Debian o Ubuntu

dpkg --install se actualiza a una versión más reciente. Las dependencias ya deben estar en la máquina virtual.

sudo env DEBIAN_FRONTEND=noninteractive dpkg --install "./appInstall.deb"

Actualizar un paquete RPM en RHEL, CentOS o SUSE

sudo rpm --upgrade --replacepkgs "./appInstall.rpm"

Actualizar un paquete TAR o de script shell en Linux

Incluya un update.sh que mantenga los datos necesarios.

rm -rf ./payload && mkdir ./payload && tar -xzf "./appInstall.tar.gz" -C ./payload && chmod +x ./payload/update.sh && sudo ./payload/update.sh
chmod +x "./appInstall.sh" && sudo "./appInstall.sh" update

Validar antes de publicar

No puede cambiar los scripts ni packageFileName después de crear una versión. En una máquina virtual de prueba, confirme lo siguiente:

  1. Entorno: La máquina virtual coincide con el sistema operativo y la arquitectura de destino. En el caso de los paquetes independientes, bloquee el acceso saliente a Internet.
  2. Nombre del paquete: El nombre de archivo descargado coincide con los scripts.
  3. Instalar: La instalación finaliza sin avisos ni reinicios y crea los archivos esperados.
  4. Repetir la instalación: La ejecución del script de instalación de nuevo se realiza correctamente.
  5. Actualización: La actualización desde cualquiera de las versiones admitidas se realiza correctamente y mantiene la configuración y los datos.
  6. Desinstalación: La eliminación solo borra los archivos de la aplicación y devuelve 0 cuando se ejecuta dos veces.
  7. Códigos de salida: El éxito devuelve 0, el fallo devuelve un valor distinto de cero y cada script espera a los procesos secundarios.
  8. Registros: Revise stdout y stderr para cada acción. Consulte Ver los registros de instalación de la aplicación mediante Run Command.
  9. Notificación de fallos: Establece treatFailureAsDeploymentFailure en true en el perfil de la aplicación para que los fallos se notifiquen como fallos de implementación.