Tworzenie i wdrażanie aplikacji maszyny wirtualnej

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

Skrypt jako ciąg:

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

Skrypt jako ciąg:

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

Skrypt jako ciąg:

"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

Skrypt jako ciąg:

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

Skrypt jako ciąg:

"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

Skrypt jako ciąg:

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

Skrypt jako ciąg:

"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

Skrypt jako ciąg:

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

Skrypt jako ciąg:

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

Skrypt jako ciąg:

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

Skrypt jako ciąg:

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

Przekazywanie plików pakietu aplikacji i konfiguracji do konta usługi Azure Storage przy użyciu portalu

Utwórz definicję aplikacji maszyny wirtualnej, używając 'create gallery application 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"
    }
}

Utwórz wersję aplikacji maszyny wirtualnej przy użyciu API do tworzenia wersji aplikacji w galerii.

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

Aplikacje maszyn wirtualnych wymagają interfejsu wiersza polecenia platformy Azure w wersji 2.30.0 lub nowszej.

Utwórz definicję aplikacji maszyny wirtualnej przy użyciu polecenia "az sig gallery-application create". W tym przykładzie tworzysz definicję aplikacji maszyny wirtualnej o nazwie myApp dla maszyn wirtualnych z systemem Linux.

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

Utwórz wersję aplikacji maszyny wirtualnej przy użyciu polecenia "az sig gallery-application version create". Dozwolone znaki dla wersji to liczby i kropki. Liczby muszą należeć do zakresu 32-bitowej liczby całkowitej. Format: MajorVersion.Wersja pomocnicza.Stosowanie poprawek.

Zastąp wartości parametrów własnymi.

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

Utwórz definicję aplikacji maszyny wirtualnej przy użyciu polecenia New-AzGalleryApplication. W tym przykładzie utworzymy aplikację systemu Linux o nazwie myApp w galerii zasobów myGallery Azure Compute i w grupie zasobów myGallery . Zastąp wartości zmiennych zgodnie z potrzebami.

$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

Utwórz wersję aplikacji maszyny wirtualnej przy użyciu polecenia New-AzGalleryApplicationVersion. Dozwolone znaki dla wersji to liczby i kropki. Liczby muszą należeć do zakresu 32-bitowej liczby całkowitej. Format: MajorVersion.Wersja pomocnicza.Stosowanie poprawek.

W tym przykładzie tworzysz numer wersji 1.0.0. Zastąp wartości zmiennych zgodnie z potrzebami.

$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. Przejdź do witryny Azure Portal, a następnie wyszukaj i wybierz pozycję Galeria obliczeń platformy Azure.
2. Wybierz galerię, której chcesz użyć z listy.
3. Na stronie galerii wybierz pozycję Dodaj w górnej części strony, a następnie z listy rozwijanej wybierz pozycję Definicja aplikacji maszyny wirtualnej. Zostanie otwarta strona Tworzenie definicji aplikacji maszyny wirtualnej.
4. Na karcie Podstawy wprowadź nazwę aplikacji i wybierz, czy aplikacja jest dla maszyn wirtualnych z systemem Linux, czy Windows.
5. Wybierz kartę Opcje publikowania , jeśli chcesz określić dowolne z następujących opcjonalnych ustawień definicji aplikacji maszyny wirtualnej:
   • Opis definicji aplikacji maszyny wirtualnej.
   • Data zakończenia życia
   • Link do umowy licencyjnej użytkownika końcowego (EULA)
   • Identyfikator URI oświadczenia o ochronie prywatności
   • Identyfikator URI informacji o wersji
6. Po zakończeniu wybierz pozycję Przejrzyj i utwórz.
7. Po zakończeniu walidacji wybierz pozycję Utwórz , aby wdrożyć definicję.
8. Po zakończeniu wdrażania wybierz pozycję Przejdź do zasobu.
9. Na stronie aplikacji wybierz pozycję Utwórz wersję aplikacji maszyny wirtualnej. Zostanie otwarta strona Tworzenie wersji aplikacji maszyny wirtualnej.
10. Wprowadź numer wersji, taki jak 1.0.0.
11. Wybierz region, w którym są przekazywane pakiety aplikacji.
12. W obszarze Źródłowy pakiet aplikacji wybierz pozycję Przeglądaj. Wybierz konto magazynu, a następnie kontener, w którym znajduje się pakiet. Wybierz pakiet z listy, a następnie wybierz pozycję Wybierz po zakończeniu. Alternatywnie możesz wkleić identyfikator URI sygnatury dostępu współdzielonego w tym polu, jeśli jest to preferowane.
13. Podaj skrypt "Zainstaluj". Można również podać skrypt "Odinstaluj" i "Aktualizuj skrypt". Aby uzyskać informacje na temat tworzenia skryptów, zobacz Omówienie.
14. Jeśli masz domyślny plik konfiguracji przekazany do konta magazynu, możesz wybrać go w obszarze Konfiguracja domyślna.
15. Wybierz pozycję Wyklucz z najnowszej wersji, jeśli ta wersja nie ma być wyświetlana jako najnowsza wersja podczas tworzenia maszyny wirtualnej.
16. W obszarze Data zakończenia życia wybierz datę w przyszłości, aby śledzić, kiedy ta wersja ma zostać wycofana. Nie jest on usuwany ani usuwany automatycznie, tylko w przypadku własnego śledzenia.
17. Aby replikować tę wersję do innych regionów, wybierz kartę Replikacja , dodaj więcej regionów i wprowadź zmiany liczby replik na region. Oryginalny region, w którym utworzono wersję, musi znajdować się na liście i nie można go usunąć.
18. Po zakończeniu wprowadzania zmian wybierz pozycję Przejrzyj i utwórz w dolnej części strony.
19. Gdy walidacja jest wyświetlana jako przekazana, wybierz pozycję Utwórz , aby wdrożyć wersję aplikacji maszyny wirtualnej.

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

Aby dodać wersję aplikacji maszyny wirtualnej do maszyny wirtualnej, wykonaj operację PUT na maszynie wirtualnej.

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

Aby zastosować aplikację maszyny wirtualnej do ujednoliconego zestawu skalowania:

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

Odpowiedź zawiera pełny model maszyny wirtualnej. Poniżej przedstawiono odpowiednie części.

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

Ustaw aplikację maszyny wirtualnej na istniejącą maszynę wirtualną przy użyciu polecenia "az vm application set" i zastąp wartości parametrów własnymi.

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

Aby ustawić wiele aplikacji na maszynie wirtualnej:

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

Aby dodać aplikację do zestawu skalowania maszyn wirtualnych, użyj polecenia "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

Aby dodać wiele aplikacji do zestawu skalowania maszyn wirtualnych:

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

Aby dodać aplikację do istniejącej maszyny wirtualnej, pobierz wersję aplikacji i użyj jej, aby uzyskać identyfikator wersji aplikacji maszyny wirtualnej. Użyj identyfikatora, aby dodać aplikację do konfiguracji maszyny wirtualnej.

$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

Aby dodać aplikację do zestawu skalowania maszyn wirtualnych:

$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

Teraz możesz utworzyć maszynę wirtualną i wdrożyć w niej aplikację maszyny wirtualnej przy użyciu portalu. Wystarczy utworzyć maszynę wirtualną jak zwykle, a następnie na karcie Zaawansowane wybierz pozycję Wybierz aplikację maszyny wirtualnej do zainstalowania.

Wybierz aplikację maszyny wirtualnej z listy, a następnie wybierz pozycję Zapisz w dolnej części strony.

Jeśli masz więcej niż jedną aplikację maszyny wirtualnej do zainstalowania, możesz ustawić kolejność instalacji dla każdej aplikacji maszyny wirtualnej z powrotem na karcie Zaawansowane.

Aplikację maszyny wirtualnej można również wdrożyć na aktualnie uruchomionych maszynach wirtualnych. Wybierz opcję Rozszerzenia i aplikacje w obszarze Ustawienia w menu po lewej stronie podczas wyświetlania szczegółów maszyny wirtualnej w portalu.

Wybierz pozycję Aplikacje maszyn wirtualnych , a następnie wybierz pozycję Dodaj aplikację , aby dodać aplikację maszyny wirtualnej.

Wybierz aplikację maszyny wirtualnej z listy, a następnie wybierz pozycję Zapisz w dolnej części strony.