Criar e implantar aplicativo VM

#!/bin/bash

# Rename blobs
mv MyVMApp app.tar
mv MyVMApp-config app-config.yaml

# Unarchive application
mkdir -p app
tar -xf app.tar -C app

# Set permissions
chmod -R +x app
chmod -R +r app

# Install the script (example: install.sh with config)
bash ./app/install.sh --config app-config.yaml

# OR Install the .deb package (example: install.deb without config)
# sudo dpkg -i ./app/install.deb

# OR Install the .rpm package (example: install.rpm without config)
# sudo rpm -ivh ./app/install.rpm

Script como string:

"#!/bin/bash\nmv MyVMApp app.tar\nmv MyVMApp-config app-config.yaml\nmkdir -p app\ntar -xf app.tar -C app\nchmod -R +x app\nchmod -R +r app\nbash ./app/install.sh --config app-config.yaml\n# sudo dpkg -i ./app/install.deb\n# sudo rpm -ivh ./app/install.rpm"

:: Rename blobs
rename MyVMApp app.zip
rename MyVMApp-config app-config.json

:: Unzip using built-in tar (available on Windows 10+)
mkdir app
tar -xf app.zip -C app

:: Install .exe application (example: setup.exe with config)
app\setup.exe /config app-config.json

:: install .msi application (example: setup.exe without config)
:: msiexec /i app\setup.msi /qn /l*v install.log

:: Install JavaScript (example: setup.js with config)
:: cscript //nologo app\setup.js app-config.json

:: Install python script (example: install.py with config) - Needs python pre-installed
:: python app\install.py app-config.json

:: Install ruby application  (example: install.rb with config) - Needs Ruby pre-installed
:: ruby app\install.rb app-config.json

Script como string:

"rename MyVMApp app.zip\r\nrename MyVMApp-config app-config.json\r\nmkdir app\r\ntar -xf app.zip -C app\r\napp\\setup.exe /config app-config.json\r\n:: msiexec /i app\\setup.msi /qn /l*v install.log\r\n:: cscript //nologo app\\setup.js app-config.json\r\n:: python app\\install.py app-config.json\r\n:: ruby app\\install.rb app-config.json"

powershell.exe -command "
# Rename blobs
Rename-Item -Path '.\MyVMApp' -NewName 'app.zip'
Rename-Item -Path '.\MyVMApp-config' -NewName 'app-config.json'

# Unzip application package
Expand-Archive -Path '.\app.zip' -DestinationPath '.\app'

# Set execution policy
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope Process -Force

# Install the .exe application (example: setup.exe with config)
Start-Process -FilePath '.\app\setup.exe' -ArgumentList '/config app-config.json' -Wait

# Install PowerShell script (example: setup.ps1 with config)
# powershell.exe -ExecutionPolicy Bypass -File '.\app\setup.ps1' -ConfigFile 'app-config.json'

# Install .msi application (example: setup.msi without config)
# Start-Process -FilePath 'msiexec.exe' -ArgumentList '/i .\app\setup.msi /qn /l*v install.log' -Wait
"

Script como string:

"powershell.exe -command \"Rename-Item -Path '.\\MyVMApp' -NewName 'app.zip'; Rename-Item -Path '.\\MyVMApp-config' -NewName 'app-config.json'; Expand-Archive -Path '.\\app.zip' -DestinationPath '.\\app'; Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope Process -Force; Start-Process -FilePath '.\\app\\setup.exe' -ArgumentList '/config app-config.json' -Wait; # powershell.exe -ExecutionPolicy Bypass -File '.\\app\\setup.ps1' -ConfigFile 'app-config.json'; # Start-Process -FilePath 'msiexec.exe' -ArgumentList '/i .\\app\\setup.msi /qn /l*v install.log' -Wait\""

:: Rename blobs
rename MyVMApp app.exe
rename MyVMApp-config app-config.json

:: Run the installer with config
app.exe /config app-config.json

Script como string:

"rename MyVMApp app.exe\r\nrename MyVMApp-config app-config.json\r\napp.exe /config app-config.json"

powershell.exe -command "
# Rename blobs
Rename-Item -Path '.\MyVMApp' -NewName 'app.exe'
Rename-Item -Path '.\MyVMApp-config' -NewName 'app-config.json'

# Set execution policy
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope Process -Force

# Install the .exe application (example: setup.exe with config)
Start-Process -FilePath '.\app.exe' -ArgumentList '/config app-config.json' -Wait
"

Script como string:

"powershell.exe -command \"Rename-Item -Path '.\\MyVMApp' -NewName 'app.exe'; Rename-Item -Path '.\\MyVMApp-config' -NewName 'app-config.json'; Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope Process -Force; Start-Process -FilePath '.\\app.exe' -ArgumentList '/config app-config.json' -Wait\""

:: Rename blobs
rename MyVMApp app.msi
rename MyVMApp-config app-config.json

:: install .msi application (example: setup.exe without config)
msiexec /i app.msi /qn /l*v install.log

Script como string:

"rename MyVMApp app.msi\r\nrename MyVMApp-config app-config.json\r\nmsiexec /i app.msi /qn /l*v install.log"

powershell.exe -command "
# Rename blobs
Rename-Item -Path '.\MyVMApp' -NewName 'app.zip'
Rename-Item -Path '.\MyVMApp-config' -NewName 'app-config.json'

# Set execution policy
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope Process -Force

# Install .msi application (example: setup.msi without config)
Start-Process -FilePath 'msiexec.exe' -ArgumentList '/i .\app\setup.msi /qn /l*v install.log' -Wait
"

Script como string:

"powershell.exe -command \"Rename-Item -Path '.\\MyVMApp' -NewName 'app.zip'; Rename-Item -Path '.\\MyVMApp-config' -NewName 'app-config.json'; Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope Process -Force; Start-Process -FilePath 'msiexec.exe' -ArgumentList '/i .\\app\\setup.msi /qn /l*v install.log' -Wait\""

#!/bin/bash

# Rename blobs
mv MyVMApp app.deb
mv MyVMApp-config app-config.yaml

# Set permissions
chmod -R +x app.deb
chmod -R +r app.deb

# Install .deb package (example: install.deb without config)
# sudo dpkg -i ./app.deb

Script como string:

"#!/bin/bash\nmv MyVMApp app.deb\nmv MyVMApp-config app-config.yaml\nchmod -R +x app.deb\nchmod -R +r app.deb\n# sudo dpkg -i ./app.deb"

#!/bin/bash

# Rename blobs
mv MyVMApp app.rpm
mv MyVMApp-config app-config.yaml

# Set permissions
chmod -R +x app.rpm
chmod -R +r app.rpm

# Install .rpm package (example: install.rpm without config)
sudo rpm -ivh ./app.rpm

Script como string:

"#!/bin/bash\nmv MyVMApp app.rpm\nmv MyVMApp-config app-config.yaml\nchmod -R +x app.rpm\nchmod -R +r app.rpm\nsudo rpm -ivh ./app.rpm"

#!/bin/bash

# Rename blobs
mv MyVMApp app.sh
mv MyVMApp-config app-config.yaml

# Set permissions
chmod -R +x app.sh
chmod -R +r app.sh

# Install the script (example: install.sh with config)
bash ./app.sh --config app-config.yaml

Script como string:

"#!/bin/bash\nmv MyVMApp app.sh\nmv MyVMApp-config app-config.yaml\nchmod -R +x app.sh\nchmod -R +r app.sh\nbash ./app.sh --config app-config.yaml"

powershell.exe -command "
# Rename blobs
Rename-Item -Path '.\MyVMApp' -NewName 'app.ps1'
Rename-Item -Path '.\MyVMApp-config' -NewName 'app-config.json'

# Set execution policy
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope Process -Force

# Install PowerShell script (example: setup.ps1 with config)
powershell.exe -ExecutionPolicy Bypass -File '.\app.ps1' -ConfigFile 'app-config.json'
"

Script como string:

"powershell.exe -command \"Rename-Item -Path '.\\MyVMApp' -NewName 'app.ps1'; Rename-Item -Path '.\\MyVMApp-config' -NewName 'app-config.json'; Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope Process -Force; powershell.exe -ExecutionPolicy Bypass -File '.\\app.ps1' -ConfigFile 'app-config.json'\""

inputFile="<the file you want to pad>"

# Get the file size
fileSize=$(stat -c %s "$inputFile")

# Calculate the remainder when divided by 512
remainder=$((fileSize % 512))

if [ "$remainder" -ne 0 ]; then
    # Calculate how many bytes to pad
    difference=$((512 - remainder))
    
    # Create padding (empty bytes)
    dd if=/dev/zero bs=1 count=$difference >> "$inputFile"
fi

$inputFile = <the file you want to pad>

$fileInfo = Get-Item -Path $inputFile

$remainder = $fileInfo.Length % 512

if ($remainder -ne 0){

    $difference = 512 - $remainder

    $bytesToPad = [System.Byte[]]::CreateInstance([System.Byte], $difference)

    Add-Content -Path $inputFile -Value $bytesToPad -Encoding Byte
    }

#!/bin/bash

# === CONFIGURATION ===
STORAGE_ACCOUNT="yourstorageaccount"
CONTAINER_NAME="yourcontainer"
LOCAL_FOLDER="./your-local-folder"
SAS_EXPIRY_HOURS=24

# === LOGIN (if not already logged in) ===
az login --only-show-errors

# === CREATE CONTAINER IF NOT EXISTS ===
az storage container create \
  --name $CONTAINER_NAME \
  --account-name $STORAGE_ACCOUNT \
  --auth-mode login \
  --only-show-errors

# === UPLOAD FILES ===
az storage blob upload-batch \
  --account-name $STORAGE_ACCOUNT \
  --destination $CONTAINER_NAME \
  --source $LOCAL_FOLDER \
  --auth-mode login \
  --only-show-errors

# === GENERATE SAS URLs ===
echo "Generating SAS URLs..."
FILES=$(find $LOCAL_FOLDER -type f)

for FILE in $FILES; do
  BLOB_NAME="${FILE#$LOCAL_FOLDER/}"
  EXPIRY=$(date -u -d "+$SAS_EXPIRY_HOURS hours" '+%Y-%m-%dT%H:%MZ')

  SAS_TOKEN=$(az storage blob generate-sas \
    --account-name $STORAGE_ACCOUNT \
    --container-name $CONTAINER_NAME \
    --name "$BLOB_NAME" \
    --permissions r \
    --expiry $EXPIRY \
    --auth-mode login \
    -o tsv)

  SAS_URL="https://${STORAGE_ACCOUNT}.blob.core.windows.net/${CONTAINER_NAME}/${BLOB_NAME}?${SAS_TOKEN}"
  echo "$BLOB_NAME: $SAS_URL"
done

# === CONFIGURATION ===
$storageAccount = "yourstorageaccount"
$containerName = "yourcontainer"
$localFolder = "C:\path\to\your\local\folder"
$sasExpiryHours = 24

# === LOGIN (if not already logged in) ===
az login | Out-Null

# === CREATE CONTAINER IF NOT EXISTS ===
az storage container create `
    --name $containerName `
    --account-name $storageAccount `
    --auth-mode login `
    --only-show-errors | Out-Null

# === UPLOAD FILES ===
az storage blob upload-batch `
    --account-name $storageAccount `
    --destination $containerName `
    --source $localFolder `
    --auth-mode login `
    --only-show-errors

# === GENERATE SAS URLs ===
Write-Host "`nGenerating SAS URLs..."
$files = Get-ChildItem -Recurse -File -Path $localFolder

foreach ($file in $files) {
    $relativePath = $file.FullName.Substring($localFolder.Length + 1).Replace("\", "/")
    $expiry = (Get-Date).ToUniversalTime().AddHours($sasExpiryHours).ToString("yyyy-MM-ddTHH:mmZ")

    $sasToken = az storage blob generate-sas `
        --account-name $storageAccount `
        --container-name $containerName `
        --name $relativePath `
        --permissions r `
        --expiry $expiry `
        --auth-mode login `
        -o tsv

    $sasUrl = "https://$storageAccount.blob.core.windows.net/$containerName/$relativePath`?$sasToken"
    Write-Host "$relativePath:`n$sasUrl`n"
}

Carregar o pacote de aplicativos e os arquivos de configuração para a Conta de Armazenamento do Azure usando o Portal

Crie a definição da aplicação da máquina virtual usando a 'API de criação de aplicações de galeria'

PUT
/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/applications/{applicationName}?api-version=2024-03-03

{
    "location": "West US",
    "name": "myApp",
    "properties": {
        "supportedOSType": "Windows | Linux",
        "endOfLifeDate": "2020-01-01",
	"description": "Description of the App",
	"eula": "Link to End-User License Agreement (EULA)",
	"privacyStatementUri": "Link to privacy statement for the application",
	"releaseNoteUri": "Link to release notes for the application"
    }
}

Crie uma versão da aplicação de VM usando a 'API de criar versão de aplicação de galeria'.

PUT
/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/applications/{applicationName}/versions/{versionName}?api-version=2024-03-03

{
  "location": "$location",
  "properties": {
    "publishingProfile": {
      "source": {
        "mediaLink": "$mediaLink",
        "defaultConfigurationLink": "$configLink"
      },
      "manageActions": {
        "install": "echo installed",
        "remove": "echo removed",
        "update": "echo update"
      },
      "targetRegions": [
        {
          "name": "West US",
          "regionalReplicaCount": 1
        },
	{
	  "name": "East US"
	}
      ]
      "endofLifeDate": "datetime",
      "replicaCount": 1,
      "excludeFromLatest": false,
      "storageAccountType": "PremiumV2_LRS | Premium_LRS | Standard_LRS | Standard_ZRS"
      "safetyProfile": {
	"allowDeletionOfReplicatedLocations": false
      }
      "settings": {
	"scriptBehaviorAfterReboot": "None | Rerun",
	"configFileName": "$appConfigFileName",
	"packageFileName": "$appPackageFileName"
      }
   }
}

Os aplicativos VM exigem a CLI do Azure versão 2.30.0 ou posterior.

Crie a definição de aplicativo VM usando 'az sig gallery-application create'. Neste exemplo, estamos criando uma definição de aplicativo VM chamada myApp para VMs baseadas em Linux.

az sig gallery-application create \
    --application-name myApp \
    --gallery-name myGallery \
    --resource-group myResourceGroup \
    --os-type Linux \
    --location "East US"

Crie uma versão do aplicativo VM usando 'az sig gallery-application version create'. Os caracteres permitidos para a versão são números e pontos. Os números devem estar dentro do intervalo de um inteiro de 32 bits. Formato: MajorVersion.Versão Menor.Adesivo.

Substitua os valores dos parâmetros pelos seus.

az sig gallery-application version create \
   --version-name 1.0.0 \
   --application-name myApp \
   --gallery-name myGallery \
   --location "East US" \
   --resource-group myResourceGroup \
   --package-file-link "https://<storage account name>.blob.core.windows.net/<container name>/<filename>" \
   --install-command "mv myApp .\myApp\myApp" \
   --remove-command "rm .\myApp\myApp" \
   --update-command  "mv myApp .\myApp\myApp" \
   --default-configuration-file-link "https://<storage account name>.blob.core.windows.net/<container name>/<filename>"\

Crie a definição de aplicativo VM usando New-AzGalleryApplication. Neste exemplo, estamos criando um aplicativo Linux chamado myApp na Galeria de Computação do Azure myGallery e no grupo de recursos myGallery . Substitua os valores das variáveis conforme necessário.

$galleryName = "myGallery"
$rgName = "myResourceGroup"
$applicationName = "myApp"
$description = "Backend Linux application for finance."
New-AzGalleryApplication `
  -ResourceGroupName $rgName `
  -GalleryName $galleryName `
  -Location "East US" `
  -Name $applicationName `
  -SupportedOSType Linux `
  -Description $description

Crie uma versão da sua aplicação VM usando New-AzGalleryApplicationVersion. Os caracteres permitidos para a versão são números e pontos. Os números devem estar dentro do intervalo de um inteiro de 32 bits. Formato: MajorVersion.Versão Menor.Adesivo.

Neste exemplo, estamos criando o número de versão 1.0.0. Substitua os valores das variáveis conforme necessário.

$galleryName = "myGallery"
$rgName = "myResourceGroup"
$applicationName = "myApp"
$version = "1.0.0"
New-AzGalleryApplicationVersion `
   -ResourceGroupName $rgName `
   -GalleryName $galleryName `
   -GalleryApplicationName $applicationName `
   -Name $version `
   -PackageFileLink "https://<storage account name>.blob.core.windows.net/<container name>/<filename>" `
   -DefaultConfigFileLink "https://<storage account name>.blob.core.windows.net/<container name>/<filename>" `
   -Location "East US" `
   -Install "mv myApp .\myApp\myApp" `
   -Remove "rm .\myApp\myApp" `

1. Vá para o portal do Azure e, em seguida, procure e selecione Galeria de Computação do Azure.
2. Selecione a galeria que deseja usar na lista.
3. Na página da sua galeria, selecione Adicionar na parte superior da página e, em seguida, selecione Definição de aplicativo VM na lista suspensa. A página Criar uma definição de aplicativo VM é aberta.
4. Na guia Noções básicas, insira um nome para seu aplicativo e escolha se o aplicativo é para VMs que executam Linux ou Windows.
5. Selecione a guia Opções de publicação se desejar especificar qualquer uma das seguintes configurações opcionais para sua definição de aplicativo VM:
   • Uma descrição da definição de aplicativo VM.
   • Data de fim de vida
   • Link para um Contrato de Licença de Usuário Final (EULA)
   • URI de uma declaração de privacidade
   • URI para notas de versão
6. Quando terminar, selecione Rever + criar.
7. Quando a validação for concluída, selecione Criar para que a definição seja implantada.
8. Quando a implantação estiver concluída, selecione Ir para o recurso.
9. Na página do aplicativo, selecione Criar uma versão do aplicativo VM. A página Criar uma versão do aplicativo VM é aberta.
10. Insira um número de versão como 1.0.0.
11. Selecione a região onde os pacotes de aplicativos são carregados.
12. Em Pacote do aplicativo de origem, selecione Procurar. Selecione a conta de armazenamento e, em seguida, o contêiner onde o pacote está localizado. Selecione o pacote na lista e, em seguida, selecione Selecionar quando terminar. Como alternativa, você pode colar o URI SAS neste campo, se preferir.
13. Forneça o 'Script de instalação'. Você também pode fornecer o 'script de desinstalação' e o 'script de atualização'. Consulte Visão geral para obter informações sobre como criar os scripts.
14. Se você tiver um arquivo de configuração padrão carregado em uma conta de armazenamento, poderá selecioná-lo em Configuração padrão.
15. Selecione Excluir da versão mais recente se não quiser que esta versão apareça como a versão mais recente quando você cria uma VM.
16. Para Data de fim de vida, escolha uma data no futuro para controlar quando esta versão deve ser aposentada. Ele não é excluído ou removido automaticamente, é apenas para seu próprio rastreamento.
17. Para replicar essa versão para outras regiões, selecione a guia Replicação , adicione mais regiões e faça alterações no número de réplicas por região. A região original onde sua versão foi criada deve estar na lista e não pode ser removida.
18. Quando terminar de fazer alterações, selecione Rever + criar na parte inferior da página.
19. Quando a validação for mostrada como aprovada, selecione Criar para implantar a versão do aplicativo VM.

name: Deploy Azure VM Application

on:
  push:
    branches:
      - main

env:
  # Customize your app and config filenames here
  APP_FILE: app.exe
  CONFIG_FILE: app-config.json

  AZURE_RESOURCE_GROUP: ${{ secrets.AZURE_RESOURCE_GROUP }}
  AZURE_LOCATION: ${{ secrets.AZURE_LOCATION }}
  AZURE_STORAGE_ACCOUNT: ${{ secrets.AZURE_STORAGE_ACCOUNT }}
  AZURE_CONTAINER_NAME: ${{ secrets.AZURE_CONTAINER_NAME }}
  GALLERY_NAME: ${{ secrets.GALLERY_NAME }}
  APPLICATION_NAME: ${{ secrets.AZURE_VM_APPLICATION_NAME }}

jobs:
  deploy:
    runs-on: ubuntu-latest

    permissions:
      id-token: write
      contents: read

    steps:
    # Step 1: Checkout repo
    - name: Checkout
      uses: actions/checkout@v4

    # Step 2: Login to Azure using OIDC
    - name: Azure Login
      uses: azure/login@v2
      with:
        client-id: ${{ secrets.AZURE_CLIENT_ID }}
        tenant-id: ${{ secrets.AZURE_TENANT_ID }}
        subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}

    # Step 3: Upload app and config files to Azure Blob
    - name: Upload files to Azure Blob Storage
      run: |
        set -euo pipefail

        echo "Creating container if missing..."
        az storage container create \
          --name "$AZURE_CONTAINER_NAME" \
          --account-name "$AZURE_STORAGE_ACCOUNT" \
          --auth-mode login \
          --only-show-errors

	echo "Uploading files..."
        az storage blob upload \
          --account-name "$AZURE_STORAGE_ACCOUNT" \
          --container-name "$AZURE_CONTAINER_NAME" \
          --name "$APP_FILE" \
          --file "$APP_FILE" \
          --auth-mode login \
          --only-show-errors

        az storage blob upload \
          --account-name "$AZURE_STORAGE_ACCOUNT" \
          --container-name "$AZURE_CONTAINER_NAME" \
          --name "$CONFIG_FILE" \
          --file "$CONFIG_FILE" \
          --auth-mode login \
          --only-show-errors

    # Step 4: Create VM Application (if missing)
    - name: Create VM Application if missing
      run: |
        set -euo pipefail

	echo "Checking for existing VM Application..."
        if ! az sig gallery-application show \
          --resource-group "$AZURE_RESOURCE_GROUP" \
          --gallery-name "$GALLERY_NAME" \
          --name "$APPLICATION_NAME" &>/dev/null; then

          az sig gallery-application create \
            --resource-group "$AZURE_RESOURCE_GROUP" \
            --gallery-name "$GALLERY_NAME" \
            --name "$APPLICATION_NAME" \
            --location "$AZURE_LOCATION" \
            --os-type Windows
        fi

    # Step 5: Generate SAS URLs
    - name: Generate SAS URLs
      id: sas
      run: |
        set -euo pipefail

	echo "Generating SAS URLs valid for 24 hours..."
        EXPIRY=$(date -u -d "+1 day" '+%Y-%m-%dT%H:%MZ')

        APP_SAS=$(az storage blob generate-sas \
          --account-name "$AZURE_STORAGE_ACCOUNT" \
          --container-name "$AZURE_CONTAINER_NAME" \
          --name "$APP_FILE" \
          --permissions r \
          --expiry "$EXPIRY" \
          --auth-mode login -o tsv)

        CONFIG_SAS=$(az storage blob generate-sas \
          --account-name "$AZURE_STORAGE_ACCOUNT" \
          --container-name "$AZURE_CONTAINER_NAME" \
          --name "$CONFIG_FILE" \
          --permissions r \
          --expiry "$EXPIRY" \
          --auth-mode login -o tsv)

        echo "APP_SAS=$APP_SAS" >> $GITHUB_ENV
        echo "CONFIG_SAS=$CONFIG_SAS" >> $GITHUB_ENV

    # Step 6: Create Application Version using semantic versioning
    - name: Create VM Application Version
      run: |
        set -euo pipefail

	# Generate a unique version name
	MAJOR=1
	MINOR=0
	PATCH=$(date +%Y%m%d)
	VERSION="$MAJOR.$MINOR.$PATCH"

	# Load install/uninstall commands from .txt files as strings
        INSTALL_CMD=$(jq -Rs '.' < install-script-as-string.txt)
        REMOVE_CMD=$(jq -Rs '.' < uninstall-script-as-string.txt)

        PACKAGE_URL="https://${AZURE_STORAGE_ACCOUNT}.blob.core.windows.net/${AZURE_CONTAINER_NAME}/${APP_FILE}?${APP_SAS}"
        CONFIG_URL="https://${AZURE_STORAGE_ACCOUNT}.blob.core.windows.net/${AZURE_CONTAINER_NAME}/${CONFIG_FILE}?${CONFIG_SAS}"

	# Create the version
        az sig gallery-application version create \
          --resource-group "$AZURE_RESOURCE_GROUP" \
          --gallery-name "$GALLERY_NAME" \
          --gallery-application-name "$APPLICATION_NAME" \
          --gallery-application-version-name "$VERSION" \
          --version-name "$VERSION" \
          --location "$AZURE_LOCATION" \
          --package-file-link "$PACKAGE_URL" \
          --default-file-link "$CONFIG_URL" \
          --install-command "$INSTALL_CMD" \
          --remove-command "$REMOVE_CMD" \
          --only-show-errors

trigger:
  branches:
    include: [ main ]

variables:
  # Customize filenames below
  APP_FILE: app.exe
  CONFIG_FILE: app-config.json

  AZURE_RESOURCE_GROUP: $(AZURE_RESOURCE_GROUP)
  AZURE_LOCATION: $(AZURE_LOCATION)
  AZURE_STORAGE_ACCOUNT: $(AZURE_STORAGE_ACCOUNT)
  AZURE_CONTAINER_NAME: $(AZURE_CONTAINER_NAME)
  GALLERY_NAME: $(GALLERY_NAME)
  APPLICATION_NAME: $(AZURE_VM_APPLICATION_NAME)

stages:
  - stage: DeployVMApp
    displayName: Upload files and deploy Azure VM Application
    jobs:
      - job: Deploy
        pool:
          vmImage: 'ubuntu-latest'
        steps:
          - checkout: self

          # Step 1: Upload files to Blob
          - task: AzureCLI@2
            displayName: Upload app (exe, zip, etc) + config to Blob
            inputs:
              azureSubscription: 'AzureServiceConnection'
              scriptType: bash
              scriptLocation: inlineScript
              inlineScript: |
                set -euo pipefail

                echo "Creating container if it doesn't exist..."
                az storage container create \
                  --name "$AZURE_CONTAINER_NAME" \
                  --account-name "$AZURE_STORAGE_ACCOUNT" \
                  --auth-mode login \
                  --only-show-errors

                echo "Uploading files..."
		az storage blob upload \
		  --account-name "$AZURE_STORAGE_ACCOUNT" \
		  --container-name "$AZURE_CONTAINER_NAME" \
		  --name "$APP_FILE" \
		  --file "$APP_FILE" \
		  --auth-mode login \
		  --only-show-errors

		az storage blob upload \
		  --account-name "$AZURE_STORAGE_ACCOUNT" \
            	  --container-name "$AZURE_CONTAINER_NAME" \
            	  --name "$CONFIG_FILE" \
            	  --file "$CONFIG_FILE" \
            	  --auth-mode login --only-show-errors

          # Step 2: Create VM Application Definition (if not exists)
          - task: AzureCLI@2
            displayName: Create VM Application Definition
            inputs:
              azureSubscription: 'AzureServiceConnection'
              scriptType: bash
              scriptLocation: inlineScript
              inlineScript: |
                set -euo pipefail

                echo "Checking for existing VM Application..."
                if ! az sig gallery-application show \
                    --resource-group "$AZURE_RESOURCE_GROUP" \
                    --gallery-name "$GALLERY_NAME" \
                    --name "$APPLICATION_NAME" &>/dev/null; then
                  echo "Creating new VM Application..."
                  az sig gallery-application create \
                    --resource-group "$AZURE_RESOURCE_GROUP" \
                    --gallery-name "$GALLERY_NAME" \
                    --application-name "$APPLICATION_NAME" \
                    --location "$AZURE_LOCATION" \
                    --os-type Windows
                else
                  echo "VM Application definition already exists."
                fi

          # Step 3: Generate SAS URLs
          - task: AzureCLI@2
            displayName: Generate SAS URLs
            inputs:
              azureSubscription: 'AzureServiceConnection'
              scriptType: bash
              scriptLocation: inlineScript
              inlineScript: |
                set -euo pipefail

                echo "Generating SAS URLs valid for 24 hours..."
                EXPIRY=$(date -u -d "+1 day" '+%Y-%m-%dT%H:%MZ')

                APP_SAS=$(az storage blob generate-sas \
		  --account-name "$AZURE_STORAGE_ACCOUNT" \
	          --container-name "$AZURE_CONTAINER_NAME" \
	          --name "$APP_FILE" \
	          --permissions r \
	          --expiry "$EXPIRY" \
	          --auth-mode login -o tsv)
	
		CONFIG_SAS=$(az storage blob generate-sas \
	          --account-name "$AZURE_STORAGE_ACCOUNT" \
	          --container-name "$AZURE_CONTAINER_NAME" \
	          --name "$CONFIG_FILE" \
	          --permissions r \
	          --expiry "$EXPIRY" \
	          --auth-mode login -o tsv)

		echo "##vso[task.setvariable variable=APP_SAS]$APP_SAS"
	        echo "##vso[task.setvariable variable=CONFIG_SAS]$CONFIG_SAS"

          # Step 4: Create VM Application Version
          - task: AzureCLI@2
            displayName: Create VM Application Version
            inputs:
              azureSubscription: 'AzureServiceConnection'
              scriptType: bash
              scriptLocation: inlineScript
              inlineScript: |
                set -euo pipefail

	       	# Generate a unique version name
                MAJOR=1
      		MINOR=0
		PATCH=$(date +%Y%m%d)
		VERSION="$MAJOR.$MINOR.$PATCH"

                # Load install/uninstall commands from .txt files as strings
                INSTALL_CMD=$(jq -Rs '.' < install-script-as-string.txt)
                REMOVE_CMD=$(jq -Rs '.' < uninstall-script-as-string.txt)

		# Load SAS URL for Application and config file
		PACKAGE_URL="https://${AZURE_STORAGE_ACCOUNT}.blob.core.windows.net/${AZURE_CONTAINER_NAME}/${APP_FILE}?${APP_SAS}"
          	CONFIG_URL="https://${AZURE_STORAGE_ACCOUNT}.blob.core.windows.net/${AZURE_CONTAINER_NAME}/${CONFIG_FILE}?${CONFIG_SAS}"

                # Create the version
                az sig gallery-application version create \
                  --resource-group "$AZURE_RESOURCE_GROUP" \
                  --gallery-name "$GALLERY_NAME" \
                  --application-name "$APPLICATION_NAME" \
                  --name "$VERSION" \
                  --location "$AZURE_LOCATION" \
                  --package-file-link "$PACKAGE_URL" \
                  --default-configuration-file-link "$CONFIG_URL" \
                  --install-command "$INSTALL_CMD" \
                  --remove-command "$REMOVE_CMD" \
                  --version-name $VERSION

stages:
  - deploy

variables:
  # Customize your filenames here
  APP_FILE: "app.exe"
  CONFIG_FILE: "app-config.json"

  AZURE_RESOURCE_GROUP: "$AZURE_RESOURCE_GROUP"
  AZURE_LOCATION: "$AZURE_LOCATION"
  AZURE_STORAGE_ACCOUNT: "$AZURE_STORAGE_ACCOUNT"
  AZURE_CONTAINER_NAME: "$AZURE_CONTAINER_NAME"
  GALLERY_NAME: "$GALLERY_NAME"
  APPLICATION_NAME: "$AZURE_VM_APPLICATION_NAME"

deploy_vm_app:
  image: mcr.microsoft.com/azure-cli
  stage: deploy
  only:
    - main
  script:
    # Login to Azure using service principal
    - az login --service-principal -u "$AZURE_CLIENT_ID" -p "$AZURE_CLIENT_SECRET" --tenant "$AZURE_TENANT_ID"
    - az account set --subscription "$AZURE_SUBSCRIPTION_ID"

    # Step 1: Upload app and config files to Blob Storage
    - |
      echo "Uploading $APP_FILE and $CONFIG_FILE to blob..."
      az storage container create \
        --name "$AZURE_CONTAINER_NAME" \
        --account-name "$AZURE_STORAGE_ACCOUNT" \
        --auth-mode login \
        --only-show-errors

      az storage blob upload \
        --account-name "$AZURE_STORAGE_ACCOUNT" \
        --container-name "$AZURE_CONTAINER_NAME" \
        --name "$APP_FILE" \
        --file "$APP_FILE" \
        --auth-mode login \
        --only-show-errors

      az storage blob upload \
        --account-name "$AZURE_STORAGE_ACCOUNT" \
        --container-name "$AZURE_CONTAINER_NAME" \
        --name "$CONFIG_FILE" \
        --file "$CONFIG_FILE" \
        --auth-mode login \
        --only-show-errors

    # Step 2: Create VM Application Definition if missing
    - |
      echo "Checking for existing VM Application..."
      if ! az sig gallery-application show \
          --resource-group "$AZURE_RESOURCE_GROUP" \
          --gallery-name "$GALLERY_NAME" \
          --application-name "$APPLICATION_NAME" &>/dev/null; then
        echo "Creating VM Application definition..."
        az sig gallery-application create \
          --resource-group "$AZURE_RESOURCE_GROUP" \
          --gallery-name "$GALLERY_NAME" \
          --application-name "$APPLICATION_NAME" \
          --location "$AZURE_LOCATION" \
          --os-type Windows \
          --only-show-errors
      else
        echo "VM Application already exists."
      fi

    # Step 3: Generate SAS URLs
    - |
      EXPIRY=$(date -u -d "+1 day" '+%Y-%m-%dT%H:%MZ')
      APP_SAS=$(az storage blob generate-sas \
        --account-name "$AZURE_STORAGE_ACCOUNT" \
        --container-name "$AZURE_CONTAINER_NAME" \
        --name "$APP_FILE" \
        --permissions r \
        --expiry "$EXPIRY" \
        --auth-mode login -o tsv)

      CONFIG_SAS=$(az storage blob generate-sas \
        --account-name "$AZURE_STORAGE_ACCOUNT" \
        --container-name "$AZURE_CONTAINER_NAME" \
        --name "$CONFIG_FILE" \
        --permissions r \
        --expiry "$EXPIRY" \
        --auth-mode login -o tsv)

    # Step 4: Create VM Application Version (semantic version: 1.0.YYYYMMDD)
    - |
      MAJOR=1
      MINOR=0
      PATCH=$(date +%Y%m%d)
      VERSION="$MAJOR.$MINOR.$PATCH"
      echo "Creating VM Application Version: $VERSION"

      INSTALL_CMD=$(jq -Rs '.' < install-script-as-string.txt)
      REMOVE_CMD=$(jq -Rs '.' < uninstall-script-as-string.txt)

      az sig gallery-application version create \
        --resource-group "$AZURE_RESOURCE_GROUP" \
        --gallery-name "$GALLERY_NAME" \
        --application-name "$APPLICATION_NAME" \
        --gallery-application-version-name "$VERSION" \
        --version-name "$VERSION" \
        --location "$AZURE_LOCATION" \
        --package-file-link "https://${AZURE_STORAGE_ACCOUNT}.blob.core.windows.net/${AZURE_CONTAINER_NAME}/${APP_FILE}?${APP_SAS}" \
        --default-configuration-file-link "https://${AZURE_STORAGE_ACCOUNT}.blob.core.windows.net/${AZURE_CONTAINER_NAME}/${CONFIG_FILE}?${CONFIG_SAS}" \
        --install-command "$INSTALL_CMD" \
        --remove-command "$REMOVE_CMD" \
        --only-show-errors

pipeline {
  agent any

  environment {
    APP_FILE = 'app.exe'
    CONFIG_FILE = 'app-config.json'

    AZURE_RESOURCE_GROUP = credentials('AZURE_RESOURCE_GROUP')
    AZURE_LOCATION = credentials('AZURE_LOCATION')
    AZURE_STORAGE_ACCOUNT = credentials('AZURE_STORAGE_ACCOUNT')
    AZURE_CONTAINER_NAME = credentials('AZURE_CONTAINER_NAME')
    GALLERY_NAME = credentials('GALLERY_NAME')
    APPLICATION_NAME = credentials('AZURE_VM_APPLICATION_NAME')

    AZURE_CLIENT_ID = credentials('AZURE_CLIENT_ID')
    AZURE_CLIENT_SECRET = credentials('AZURE_CLIENT_SECRET')
    AZURE_TENANT_ID = credentials('AZURE_TENANT_ID')
    AZURE_SUBSCRIPTION_ID = credentials('AZURE_SUBSCRIPTION_ID')
  }

  stages {
    stage('Login to Azure') {
      steps {
        sh '''
          az login --service-principal \
            --username "$AZURE_CLIENT_ID" \
            --password "$AZURE_CLIENT_SECRET" \
            --tenant "$AZURE_TENANT_ID"
          az account set --subscription "$AZURE_SUBSCRIPTION_ID"
        '''
      }
    }

    stage('Upload to Blob Storage') {
      steps {
        sh '''
          az storage container create \
            --name "$AZURE_CONTAINER_NAME" \
            --account-name "$AZURE_STORAGE_ACCOUNT" \
            --auth-mode login --only-show-errors

          az storage blob upload \
            --account-name "$AZURE_STORAGE_ACCOUNT" \
            --container-name "$AZURE_CONTAINER_NAME" \
            --name "$APP_FILE" \
            --file "$APP_FILE" \
            --auth-mode login --only-show-errors

          az storage blob upload \
            --account-name "$AZURE_STORAGE_ACCOUNT" \
            --container-name "$AZURE_CONTAINER_NAME" \
            --name "$CONFIG_FILE" \
            --file "$CONFIG_FILE" \
            --auth-mode login --only-show-errors
        '''
      }
    }

    stage('Create VM Application if Needed') {
      steps {
        sh '''
          if ! az sig gallery-application show \
            --resource-group "$AZURE_RESOURCE_GROUP" \
            --gallery-name "$GALLERY_NAME" \
            --application-name "$APPLICATION_NAME" &>/dev/null; then
            az sig gallery-application create \
              --resource-group "$AZURE_RESOURCE_GROUP" \
              --gallery-name "$GALLERY_NAME" \
              --application-name "$APPLICATION_NAME" \
              --location "$AZURE_LOCATION" \
              --os-type Windows
          fi
        '''
      }
    }

    stage('Generate SAS URLs') {
      steps {
        sh '''
          export EXPIRY=$(date -u -d "+1 day" '+%Y-%m-%dT%H:%MZ')
          export APP_SAS=$(az storage blob generate-sas \
            --account-name "$AZURE_STORAGE_ACCOUNT" \
            --container-name "$AZURE_CONTAINER_NAME" \
            --name "$APP_FILE" \
            --permissions r \
            --expiry "$EXPIRY" \
            --auth-mode login -o tsv)

          export CONFIG_SAS=$(az storage blob generate-sas \
            --account-name "$AZURE_STORAGE_ACCOUNT" \
            --container-name "$AZURE_CONTAINER_NAME" \
            --name "$CONFIG_FILE" \
            --permissions r \
            --expiry "$EXPIRY" \
            --auth-mode login -o tsv)

          echo "APP_SAS=$APP_SAS" > sas.env
          echo "CONFIG_SAS=$CONFIG_SAS" >> sas.env
        '''
      }
    }

    stage('Create Application Version') {
      steps {
        sh '''
          source sas.env

          MAJOR=1
          MINOR=0
          PATCH=$(date +%Y%m%d)
          VERSION="$MAJOR.$MINOR.$PATCH"

          INSTALL_CMD=$(jq -Rs '.' < install-script-as-string.txt)
          REMOVE_CMD=$(jq -Rs '.' < uninstall-script-as-string.txt)

          az sig gallery-application version create \
            --resource-group "$AZURE_RESOURCE_GROUP" \
            --gallery-name "$GALLERY_NAME" \
            --application-name "$APPLICATION_NAME" \
            --gallery-application-version-name "$VERSION" \
            --version-name "$VERSION" \
            --location "$AZURE_LOCATION" \
            --package-file-link "https://${AZURE_STORAGE_ACCOUNT}.blob.core.windows.net/${AZURE_CONTAINER_NAME}/${APP_FILE}?$APP_SAS" \
            --default-configuration-file-link "https://${AZURE_STORAGE_ACCOUNT}.blob.core.windows.net/${AZURE_CONTAINER_NAME}/${CONFIG_FILE}?$CONFIG_SAS" \
            --install-command "$INSTALL_CMD" \
            --remove-command "$REMOVE_CMD" \
            --only-show-errors
        '''
      }
    }
  }
}

Para adicionar uma versão de aplicativo VM a uma VM, execute um PUT na VM.

PUT
/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{VMName}?api-version=2024-03-03

{
  "properties": {
    "applicationProfile": {
      "galleryApplications": [
        {
          "order": 1,
          "packageReferenceId": "/subscriptions/{subscriptionId}/resourceGroups/<resource group>/providers/Microsoft.Compute/galleries/{gallery name}/applications/{application name}/versions/{version | latest}",
          "configurationReference": "{path to configuration storage blob}",
          "treatFailureAsDeploymentFailure": false
        }
      ]
    }
  },
  "name": "{vm name}",
  "id": "/subscriptions/{subscriptionId}/resourceGroups/{resource group}/providers/Microsoft.Compute/virtualMachines/{vm name}",
  "location": "{vm location}"
}

Para aplicar o aplicativo VM a um conjunto de escala uniforme:

PUT
/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{VMSSName}?api-version=2024-03-03

{
  "properties": {
    "virtualMachineProfile": {
      "applicationProfile": {
        "galleryApplications": [
          {
            "order": 1,
            "packageReferenceId": "/subscriptions/{subscriptionId}/resourceGroups/<resource group>/providers/Microsoft.Compute/galleries/{gallery name}/applications/{application name}/versions/{version | latest}",
            "configurationReference": "{path to configuration storage blob}",
            "treatFailureAsDeploymentFailure": false
          }
        ]
      }
    }
  },
  "name": "{vm name}",
  "id": "/subscriptions/{subscriptionId}/resourceGroups/{resource group}/providers/Microsoft.Compute/virtualMachines/{vm name}",
  "location": "{vm location}"
}

A resposta inclui o modelo de VM completo. Seguem-se as partes relevantes.

{
  "name": "{vm name}",
  "id": "{vm id}",
  "type": "Microsoft.Compute/virtualMachines",
  "location": "{vm location}",
  "properties": {
    "applicationProfile": {
      "galleryApplications": ""
    },
    "provisioningState": "Updating"
  },
  "resources": [
    {
      "name": "VMAppExtension",
      "id": "{extension id}",
      "type": "Microsoft.Compute/virtualMachines/extensions",
      "location": "centraluseuap",
      "properties": "@{autoUpgradeMinorVersion=True; forceUpdateTag=7c4223fc-f4ea-4179-ada8-c8a85a1399f5; provisioningState=Creating; publisher=Microsoft.CPlat.Core; type=VMApplicationManagerLinux; typeHandlerVersion=1.0; settings=}"
    }
  ]
}

Defina um aplicativo VM para uma VM existente usando 'az vm application set' e substitua os valores dos parâmetros pelos seus próprios.

az vm application set \
	--resource-group myResourceGroup \
	--name myVM \
  	--app-version-ids /subscriptions/{subID}/resourceGroups/MyResourceGroup/providers/Microsoft.Compute/galleries/myGallery/applications/myApp/versions/1.0.0 \
  	--treat-deployment-as-failure true

Para definir vários aplicativos em uma VM:

az vm application set \
	--resource-group myResourceGroup \
	--name myVM \
	--app-version-ids /subscriptions/{subId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/myGallery/applications/myApp/versions/1.0.0 /subscriptions/{subId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/myGallery/applications/myApp2/versions/1.0.1 \
	--treat-deployment-as-failure true true

Para adicionar uma aplicação a um Conjunto de Escala de Máquinas Virtuais, use 'az vmss application set':

az vmss application set \
	--resource-group myResourceGroup \
	--name myVmss \
	--app-version-ids /subscriptions/{subId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/myGallery/applications/myApp/versions/1.0.0 \
	--treat-deployment-as-failure true

Para adicionar vários aplicativos a um Conjunto de Dimensionamento de Máquina Virtual:

az vmss application set \
	--resource-group myResourceGroup \
	--name myVmss
	--app-version-ids /subscriptions/{subId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/myGallery/applications/myApp/versions/1.0.0 /subscriptions/{subId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/myGallery/applications/myApp2/versions/1.0.0 \
	--treat-deployment-as-failure true

Para adicionar o aplicativo a uma VM existente, obtenha a versão do aplicativo e use-a para obter a ID da versão do aplicativo VM. Use a ID para adicionar o aplicativo à configuração da VM.

$galleryName = "myGallery"
$rgName = "myResourceGroup"
$applicationName = "myApp"
$version = "1.0.0"
$vmName = "myVM"
$vm = Get-AzVM -ResourceGroupName $rgname -Name $vmName
$appVersion = Get-AzGalleryApplicationVersion `
   -GalleryApplicationName $applicationName `
   -GalleryName $galleryName `
   -Name $version `
   -ResourceGroupName $rgName
$packageId = $appVersion.Id
$app = New-AzVmGalleryApplication -PackageReferenceId $packageId
Add-AzVmGalleryApplication -VM $vm -GalleryApplication $app -TreatFailureAsDeploymentFailure true
Update-AzVM -ResourceGroupName $rgName -VM $vm

Para adicionar a aplicação a um Conjunto de Dimensionamento de Máquina Virtual:

$vmss = Get-AzVmss -ResourceGroupName $rgname -Name $vmssName
$appVersion = Get-AzGalleryApplicationVersion `
   -GalleryApplicationName $applicationName `
   -GalleryName $galleryName `
   -Name $version `
   -ResourceGroupName $rgName
$packageId = $appVersion.Id
$app = New-AzVmssGalleryApplication -PackageReferenceId $packageId
Add-AzVmssGalleryApplication -VirtualMachineScaleSetVM $vmss.VirtualMachineProfile -GalleryApplication $app
Update-AzVmss -ResourceGroupName $rgName -VirtualMachineScaleSet $vmss -VMScaleSetName $vmssName

Agora você pode criar uma VM e implantar o aplicativo VM nela usando o portal. Basta criar a VM como de costume e, na guia Avançado , escolha Selecionar um aplicativo VM para instalar.

Selecione o aplicativo VM na lista e, em seguida, selecione Salvar na parte inferior da página.

Se você tiver mais de um aplicativo VM para instalar, poderá definir a ordem de instalação para cada aplicativo VM novamente na guia Avançado.

Você também pode implantar o aplicativo VM em VMs em execução no momento. Selecione a opção Extensões + aplicativos em Configurações no menu esquerdo ao visualizar os detalhes da VM no portal.

Escolha aplicativos VM e, em seguida, selecione Adicionar aplicativo para adicionar seu aplicativo VM.

Selecione o aplicativo VM na lista e, em seguida, selecione Salvar na parte inferior da página.