Skapa och distribuera VM-program

#!/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

Skript som sträng:

"#!/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

Skript som sträng:

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

Skript som sträng:

"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

Skript som sträng:

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

Skript som sträng:

"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

Skript som sträng:

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

Skript som sträng:

"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

Skript som sträng:

"#!/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

Skript som sträng:

"#!/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

Skript som sträng:

"#!/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'
"

Skript som sträng:

"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"
}

Ladda upp programpaket och konfigurationsfiler till Azure Storage-konto med hjälp av portalen

Skapa vm-programdefinitionen med hjälp av "skapa galleriprogram-API"

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"
    }
}

Skapa en vm-programversion med hjälp av API:et "create gallery application version".

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"
      }
   }
}

Vm-program kräver Azure CLI version 2.30.0 eller senare.

Skapa vm-programdefinitionen med hjälp av "az sig gallery-application create". I det här exemplet skapar vi en vm-programdefinition med namnet myApp för Linux-baserade virtuella datorer.

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

Skapa en vm-programversion med hjälp av "az sig gallery-application version create". Tillåtna tecken för version är siffror och punkter. Tal måste ligga inom intervallet för ett 32-bitars heltal. Format: MajorVersion.MinorVersion.Korrigering.

Ersätt parametrarnas värden med dina egna.

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>"\

Skapa den virtuella datorns programdefinition med hjälp av New-AzGalleryApplication. I det här exemplet skapar vi en Linux-app med namnet myApp i myGallery Azure Compute Gallery och i resursgruppen myGallery . Ersätt värdena för variabler efter behov.

$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

Skapa en version av ditt VM-program med .New-AzGalleryApplicationVersion Tillåtna tecken för version är siffror och punkter. Tal måste ligga inom intervallet för ett 32-bitars heltal. Format: MajorVersion.MinorVersion.Korrigering.

I det här exemplet skapar vi versionsnummer 1.0.0. Ersätt värdena för variablerna efter behov.

$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. Gå till Azure-portalen och sök sedan efter och välj Azure Compute Gallery.
2. Välj det galleri som du vill använda i listan.
3. På sidan för galleriet väljer du Lägg till överst på sidan och väljer sedan VM-programdefinition i listrutan. Sidan Skapa en vm-programdefinition öppnas.
4. På fliken Grundläggande anger du ett namn för ditt program och väljer om programmet är för virtuella datorer som kör Linux eller Windows.
5. Välj fliken Publiceringsalternativ om du vill ange någon av följande valfria inställningar för den virtuella datorns programdefinition:
   • En beskrivning av den virtuella datorns programdefinition.
   • Slutdatum
   • Länk till ett licensavtal för slutanvändare (EULA)
   • URI för en sekretesspolicy
   • URI för viktig information
6. När du är klar väljer du Granska + skapa.
7. När verifieringen är klar väljer du Skapa för att få definitionen distribuerad.
8. När distributionen är klar väljer du Gå till resurs.
9. På sidan för programmet väljer du Skapa en vm-programversion. Sidan Skapa en vm-programversion öppnas.
10. Ange ett versionsnummer som 1.0.0.
11. Välj den region där programpaketen laddas upp.
12. Under Källprogrampaket väljer du Bläddra. Välj lagringskontot och sedan containern där paketet finns. Välj paketet i listan och välj sedan Välj när du är klar. Du kan också klistra in SAS-URI:n i det här fältet om du vill.
13. Ange installationsskriptet. Du kan också ange avinstallationsskriptet och uppdateringsskriptet. Se Översikt för information om hur du skapar skripten.
14. Om du har en standardkonfigurationsfil som laddats upp till ett lagringskonto kan du välja den i Standardkonfiguration.
15. Välj Exkludera från den senaste versionen om du inte vill att den här versionen ska visas som den senaste versionen när du skapar en virtuell dator.
16. För Slutdatum väljer du ett datum i framtiden för att spåra när den här versionen ska dras tillbaka. Det tas inte bort eller tas inte bort automatiskt, det är bara för din egen spårning.
17. Om du vill replikera den här versionen till andra regioner väljer du fliken Replikering , lägger till fler regioner och gör ändringar i antalet repliker per region. Den ursprungliga regionen där din version skapades måste finnas i listan och kan inte tas bort.
18. När du är klar med ändringarna väljer du Granska + skapa längst ned på sidan.
19. När verifieringen visas som godkänd väljer du Skapa för att distribuera den virtuella datorns programversion.

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
        '''
      }
    }
  }
}

Om du vill lägga till en vm-programversion till en virtuell dator utför du en PUT på den virtuella datorn.

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}"
}

Så här tillämpar du det virtuella datorprogrammet på en enhetlig skalningsuppsättning:

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}"
}

Svaret innehåller den fullständiga VM-modellen. Följande är relevanta delar.

{
  "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=}"
    }
  ]
}

Ange ett virtuellt datorprogram till en befintlig virtuell dator med hjälp av "az vm application set" och ersätt parametrarnas värden med dina egna.

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

För att ställa in flera program på en virtuell dator:

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

Om du vill lägga till ett program i en VM-skalningsuppsättning använder du "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

Så här lägger du till flera program i en VM-skalningsuppsättning:

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

Om du vill lägga till programmet i en befintlig virtuell dator hämtar du programversionen och använder den för att hämta version-ID:t för den virtuella datorns program. Använd ID:t för att lägga till programmet i vm-konfigurationen.

$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

Så här lägger du till programmet i en VM-skalningsuppsättning:

$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

Nu kan du skapa en virtuell dator och distribuera det virtuella datorprogrammet till den med hjälp av portalen. Skapa bara den virtuella datorn som vanligt, och under fliken Avancerat väljer du Välj ett VM-program att installera.

Välj det virtuella datorprogrammet i listan och välj sedan Spara längst ned på sidan.

Om du har fler än ett vm-program att installera kan du ställa in installationsordningen för varje vm-program på fliken Avancerat.

Du kan också distribuera det virtuella datorprogrammet till virtuella datorer som körs. Välj alternativet Tillägg + program under Inställningar på den vänstra menyn när du visar information om den virtuella datorn i portalen.

Välj VM-program och välj sedan Lägg till program för att lägga till ditt VM-program.

Välj det virtuella datorprogrammet i listan och välj sedan Spara längst ned på sidan.