Condividi tramite

Creare e distribuire un'applicazione vm

L'applicazione VM è un tipo di risorsa in Azure Raccolta di calcolo che semplifica la pubblicazione, la distribuzione, la gestione, la condivisione e la distribuzione globale di applicazioni e script per le macchine virtuali. Le applicazioni VM supportano un'ampia gamma di scenari, tra cui distribuzioni su larga scala, requisiti di bassa latenza, resilienza degli errori, implementazioni attendibili sicure, coerenza a livello di flotta, architetture di microservizi e gestione post-distribuzione. Altre informazioni sulle applicazioni di macchine virtuali.

Per creare e distribuire applicazioni sulla macchina virtuale di Azure, crea prima di tutto il pacchetto e carica l'applicazione nell'account di archiviazione di Azure come blob di archiviazione. Creare quindi la risorsa Azure VM application e la risorsa VM application version che fanno riferimento a questi BLOB di archiviazione. Azure archivia e replica questi BLOB negli account di archiviazione gestiti a livello di area. Infine, distribuire l'applicazione su qualsiasi macchina virtuale o set di scalabilità di macchine virtuali passando il riferimento all'applicazione in applicationProfile.

Diagramma che illustra il processo dettagliato relativo alla pubblicazione e alla distribuzione di applicazioni di macchine virtuali.

Prerequisiti

  1. Creare account di archiviazione Azure e contenitore di archiviazione. Questo contenitore viene usato per caricare i file dell'applicazione.
  2. Creare Azure Compute Gallery per memorizzare e condividere risorse applicative.
  3. Creare un'identità gestita assegnata dall'utente e assegnarla ad Azure Compute Gallery

Annotazioni

Creare l'account di archiviazione con accesso anonimo disabilitato per migliorare la sicurezza. Usare un'identità gestita assegnata alla Raccolta di calcolo di Azure per pubblicare le applicazioni della macchina virtuale in modo sicuro senza richiedere token SAS.

Creare un pacchetto dell'applicazione

Prima di pubblicare la risorsa applicazione VM in Azure Compute Gallery, creare un pacchetto con i file dell'applicazione da caricare nell'Azure Storage Account. Il diagramma seguente mostra le possibili strutture di cartelle per organizzare i file dell'applicazione:

Screenshot che mostra la struttura di cartelle consigliata per il caricamento e la creazione di applicazioni vm.

1. Creare un pacchetto dei file dell'applicazione

L'applicazione VM richiede un singolo file come pacchetto dell'applicazione.

  • Se l'installazione dell'applicazione richiede un singolo file eseguibile (.exe, .msi, .sh, .ps e così via), è possibile usarlo come pacchetto dell'applicazione.
  • Se l'applicazione richiede più file (eseguibili, dipendenze, script, metadati e così via), archiviarli in un singolo file (, , ) e usare questo file come pacchetto dell'applicazione.
  • Per l'applicazione di microservizi, è possibile creare un pacchetto e pubblicare ogni microservizio come applicazione di macchina virtuale Azure separata. Questa modularizzazione facilita il riutilizzo delle applicazioni, lo sviluppo tra team e l'installazione sequenziale dei microservizi usando la proprietà nel file applicationProfile.

Scopri di più su creazione di pacchetti applicativi per le applicazioni VM di Azure.

2. (Facoltativo) Creare un pacchetto del file di configurazione dell'applicazione

  • È possibile specificare il file di configurazione separatamente usando nell'oggetto dell'applicazione della macchina virtuale. In questo modo si riduce il sovraccarico dell'archiviazione e dell'eliminazione dei pacchetti dell'applicazione.
  • I file di configurazione possono essere passati anche durante la distribuzione dell'app usando la proprietà della macchina virtuale che abilita l'installazione personalizzata per ogni macchina virtuale.
  • Se entrambe le proprietà sono impostate, esegue l'override della configurazione passata usando .

3. Creare lo script di installazione

Dopo il download dell'applicazione e del BLOB di configurazione nella macchina virtuale, Azure esegue lo script di installazione fornito per installare l'applicazione. Lo script di installazione viene fornito come stringa e ha un limite massimo di caratteri di 4.096 caratteri. I comandi di installazione devono essere scritti presupponendo che il pacchetto dell'applicazione e il file di configurazione si trovino nella directory corrente.

Potrebbero essere necessarie poche operazioni nello script di installazione

  • (Facoltativo) Usare l'interprete dei comandi corretto L'interprete dei comandi predefinito usato da Azure è /bin/bash nel sistema operativo Linux e cmd.exe nel sistema operativo Windows. È possibile usare un interprete diverso, ad esempio Chocolatey o PowerShell, se installato nel computer. Chiama l'eseguibile e passa i comandi ad esso. Ad esempio: . Se si usa PowerShell, è necessario usare la versione 3.11.0 del modulo Az.Storage.

  • (Facoltativo) Rinominare BLOB dell'applicazione e BLOB di configurazione Azure non può conservare il nome del BLOB originale e le estensioni di file. Azure scarica il file dell'applicazione con il nome della risorsa dell'applicazione VM pubblicata nella Azure Compute Gallery. Se quindi il nome dell'app vm è "VMApp1", il file scaricato nella macchina virtuale ha il nome "VMApp1" senza un'estensione. Il file di configurazione ha un nome predefinito come "VMApp1-config" senza un'estensione di file.

    È possibile rinominare il file con l'estensione del file utilizzando lo script di installazione o è possibile passare i nomi nelle proprietà e della risorsa di versione dell'applicazione VM . Azure usa questi nomi anziché i nomi predefiniti durante il download dei file.

  • Decomprimere il blob dell'applicazione Per i pacchetti di applicazioni archiviati, è necessario decomprimerli prima di installare l'applicazione. Usare .zip o .tar poiché la maggior parte dei sistemi operativi ha il supporto predefinito per estrarre questi formati. Per altri formati, assicurarsi che il sistema operativo guest fornisca supporto.

  • Converti lo script in una stringa Lo script di installazione viene passato come stringa per la proprietà install nella risorsa publishingProfile della versione dell'applicazione Azure VM.

  • Installare silenziosamente e sincrono Installare le applicazioni silenziosamente senza alcuna richiesta dell'interfaccia utente. Poiché l'installazione viene eseguita in una macchina virtuale in cui l'input del cliente non è disponibile, è necessario usare flag di installazione automatica o invisibile all'utente. Inoltre, se il programma di installazione dell'applicazione genera processi in background o processi figlio o viene eseguito in modo asincrono, lo script principale potrebbe concludersi prima del completamento dell'installazione. Per assicurarsi che l'installazione completa venga completata prima che Azure contrassegni l'operazione con esito positivo, usare i flag di attesa o i comandi di blocco. Questo approccio è utile quando l'installazione prevede più passaggi che vengono eseguiti in modo asincrono oppure è necessario verificare il completamento dell'installazione prima dell'inizio dell'applicazione successiva nella sequenza.

    Esempi comuni prevedono:

    • Windows .msi: start /wait msiexec /i app.msi /quiet /qn
    • Windows .exe: start /wait app.exe /silent o start /wait app.exe /quiet o start /wait app.exe /S
    • PowerShell:
    • Linux .sh: (gli script della shell vengono eseguiti in modo sincrono per impostazione predefinita)
    • Linux .deb: (viene eseguito in modo sincrono per impostazione predefinita)
    • Linux .rpm: (viene eseguito in modo sincrono per impostazione predefinita)

  • (Facoltativo) Impostare correttamente i criteri di esecuzione e le autorizzazioni Dopo la decompressione, le autorizzazioni dei file potrebbero essere reimpostate. È consigliabile impostare le autorizzazioni corrette prima di eseguire i file.

  • (Facoltativo) L'impostazione dell'esecuzione dettagliata e la registrazione delle applicazioni della macchina virtuale consentono di acquisire automaticamente qualsiasi output dallo script di installazione e di archiviarlo in un file stdout nella macchina virtuale. Usare questa funzionalità per registrare lo stato dell'installazione, gli errori di debug e verificare le distribuzioni riuscite.

    • Abilitare la modalità dettagliata per acquisire i log del programma di installazione dell'applicazione. Bash: , PowerShell: , Cmd: .
    • Aggiungere messaggi personalizzati per tenere traccia dello stato dello script. Bash: , PowerShell: , Cmd:

    È possibile recuperare questi log usando Esegui comando o connettendosi alla macchina virtuale. I file e si trovano nel percorso seguente

    • Linux:
    • Windows: C:\Packages\Plugins\Microsoft.CPlat.Core.VMApplicationManagerWindows\1.0.9\Downloads\<application name>\<application version>/

  • (facoltativo) Spostare l'applicazione e il BLOB di configurazione nel percorso appropriato Azure scarica il BLOB dell'applicazione e il BLOB di configurazione nei percorsi seguenti. Lo script di installazione deve spostare i file in percorsi appropriati, se necessario.

    Linux:

    Windows: C:\Packages\Plugins\Microsoft.CPlat.Core.VMApplicationManagerWindows\1.0.16\Downloads\<application name>\<application version>

Ecco alcuni script di installazione di esempio basati sull'estensione di file del BLOB dell'applicazione. Se le proprietà & vengono fornite in con il nome e l'estensione del file, rimuovere il codice per rinominare i file negli script seguenti.

  • .TAR
  • .ZIP
  • .EXE
  • .MSI
  • .DEB
  • . RPM
  • .SH
  • .PS1

Sostituire con il nome dell'app della macchina virtuale nel pacchetto dell'applicazione (VMApp1) e nel file di configurazione (VMApp1-config). Sostituire con il nome dell'app desiderato. Sostituire con il nome di configurazione desiderato.

Eseguire l'installazione con bash senza file di configurazione:

mv VMApp1 app.tar && tar -xf app.tar && chmod -R +xr . && bash ./install.sh

mv VMApp1 app.tar && tar -xf app.tar && chmod -R +xr . && sudo DEBIAN_FRONTEND=noninteractive dpkg -i ./app.deb

Eseguire l'installazione con bash con il file di configurazione:

mv VMApp1 app.tar && mv VMApp1-config config.yaml && tar -xf app.tar && chmod -R +xr . && bash ./install.sh --config config.yaml

Se il file di configurazione viene creato in un pacchetto all'interno del file tar

mv VMApp1 app.tar && tar -xf app.tar && chmod -R +xr . && sudo debconf-set-selections < config.cfg && sudo DEBIAN_FRONTEND=noninteractive dpkg -i ./app.deb

4. Creare lo script di rimozione

Lo script consente di definire le operazioni per la rimozione dell'applicazione. Lo script viene fornito come stringa e ha un limite massimo di caratteri di 4.096 caratteri. Scrivere i comandi presupponendo che il pacchetto dell'applicazione e il file di configurazione si trovino nella directory corrente. Durante l'operazione di disinstallazione, Azure esegue lo script di disinstallazione e quindi elimina tutti i file dal repository.

Esistono poche operazioni che lo script deve eseguire.

  • Disinstallare l'applicazione: Disinstallare correttamente l'applicazione dalla macchina virtuale. Per esempio:
  • CMD
  • PowerShell
  • Bash

CMD su Windows:

start /wait uninstall.exe /quiet

start /wait python.exe /uninstall /quiet

start /wait msiexec /x app.msi /quiet /qn
  • Rimuovere i file residui: Se l'installazione dell'applicazione crea file in altre parti del file system, rimuovere tali file.

Caricare i file dell'applicazione in Azure account di archiviazione

Importante

Prima di caricare file o generare URL SAS, assegnare ruoli all'utente, al principale del servizio o all'identità gestita che esegue tali operazioni sull'account di archiviazione di destinazione o sul contenitore:

  • Collaboratore dati BLOB di archiviazione o Proprietario dati BLOB di archiviazione: necessario per caricare, modificare o eliminare BLOB.
  • Per generare una firma di accesso condiviso con Azure AD, ad esempio usando l'accesso --auth-mode nell'interfaccia della riga di comando/PowerShell, assegnare anche il ruolo Delegato BLOB di archiviazione a livello di ambito dell'account di archiviazione.

1. Carica la tua applicazione e i file di configurazione in un contenitore nel tuo account di archiviazione Azure.

Caricare l'applicazione in pacchetto e il file di configurazione facoltativo come BLOB. I BLOB di blocco funzionano nella maggior parte dei casi.

(Facoltativo) Se è necessario usare BLOB di pagine, allineare i file ai byte prima di caricarli usando uno degli script seguenti:

  • CLI
  • PowerShell 
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

2. Generare l'URL SAS o l'URL Blob per il pacchetto dell'applicazione e il file di configurazione

Dopo che l'applicazione e i file di configurazione vengono caricati nell'account di archiviazione, è necessario generare un URL del blob o un URL SAS con privilegi di lettura per questo blob. Questi URL vengono quindi forniti come riferimento durante la creazione della risorsa della versione dell'applicazione della macchina virtuale.

Annotazioni

L'uso di URL BLOB con identità gestita è fortemente consigliato per migliorare la sicurezza e la privacy.

Usare l'URL del BLOB:

  • Se viene assegnata un'identità gestita ad Azure Compute Gallery.
  • Se l'account di archiviazione è abilitato per l'accesso anonimo. Usare questo metodo solo per i test perché non è sicuro.

Usare l'URL SAS:

  • Se l'account di archiviazione è disabilitato per l'accesso anonimo e l'identità gestita è assegnata alla Raccolta di calcolo di Azure.

URL BLOB = https://${STORAGE_ACCOUNT}.blob.core.windows.net/${CONTAINER_NAME}/${BLOB_NAME} SAS URL = https://${STORAGE_ACCOUNT}.blob.core.windows.net/${CONTAINER_NAME}/${BLOB_NAME}?${SAS_TOKEN}

  • Interfaccia della riga di comando utilizzando URL Blob
  • CLI con URL SAS
  • PowerShell utilizzando URL Blob
  • PowerShell con URL SAS
  • Portale

Usare il seguente script se l'identità gestita è assegnata a l'Azure Compute Gallery. Questo approccio utilizza URL BLOB senza token SAS.

#!/bin/bash
set -euo pipefail

# === CONFIGURATION ===
STORAGE_ACCOUNT="your-storage-account-name"
CONTAINER_NAME="your-container-name"
APP_FILE="./path/to/your-app-file"           # Path to your application payload file        
CONFIG_FILE="./path/to/your-config-file"     # Path to your configuration file (optional)   

# === 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 APPLICATION FILE ===
APP_BLOB_NAME=$(basename "$APP_FILE")
az storage blob upload \
  --account-name "$STORAGE_ACCOUNT" \
  --container-name "$CONTAINER_NAME" \
  --name "$APP_BLOB_NAME" \
  --file "$APP_FILE" \
  --auth-mode login \
  --overwrite \
  --only-show-errors

# === UPLOAD CONFIG FILE (optional) ===
if [ -n "$CONFIG_FILE" ] && [ -f "$CONFIG_FILE" ]; then
  CONFIG_BLOB_NAME=$(basename "$CONFIG_FILE")
  az storage blob upload \
    --account-name "$STORAGE_ACCOUNT" \
    --container-name "$CONTAINER_NAME" \
    --name "$CONFIG_BLOB_NAME" \
    --file "$CONFIG_FILE" \
    --auth-mode login \
    --overwrite \
    --only-show-errors
fi

# === GENERATE BLOB URLs ===
echo "Generating Blob URLs..."

APP_BLOB_URL="https://${STORAGE_ACCOUNT}.blob.core.windows.net/${CONTAINER_NAME}/${APP_BLOB_NAME}"
echo "Application file: $APP_BLOB_URL"

if [ -n "$CONFIG_FILE" ] && [ -f "$CONFIG_FILE" ]; then
  CONFIG_BLOB_URL="https://${STORAGE_ACCOUNT}.blob.core.windows.net/${CONTAINER_NAME}/${CONFIG_BLOB_NAME}"
  echo "Configuration file: $CONFIG_BLOB_URL"
fi

Creare l'applicazione vm

Per creare l'applicazione vm, creare prima di tutto la risorsa applicazione vm , che descrive l'applicazione. Creare la risorsa Versione applicazione della macchina virtuale al suo interno, che contiene il payload dell'applicazione della macchina virtuale e gli script per installare, aggiornare ed eliminare l'applicazione. Il payload viene fornito usando un URL BLOB o un URL della firma di accesso condiviso al contenitore BLOB nell'account di archiviazione di Azure.

Per altre informazioni su ogni proprietà, consultare lo schema per l'applicazione VM e la risorsa della versione dell'applicazione VM.

Usare il modello ARM seguente per creare una Raccolta di calcolo di Azure, un'applicazione della macchina virtuale e una versione dell'applicazione della macchina virtuale. Questo modello illustra le proprietà chiave e le opzioni di configurazione per la pubblicazione del pacchetto dell'applicazione.

{
  "$schema": "https://schema.management.azure.com/schemas/2020-06-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "galleryName": {
      "type": "string"
    },
    "applicationName": {
      "type": "string"
    },
    "versionName": {
      "type": "string",
      "metadata": {
        "description": "Must follow the format: major.minor.patch (Example: 1.0.0)"
      }
    },
    "location": {
      "type": "string",
      "defaultValue": "West US"
    },
    "supportedOSType": {
      "type": "string",
      "allowedValues": ["Windows", "Linux"]
    },
    "endOfLifeDate": {
      "type": "string",
      "metadata": {
        "description": "Optional. This property is for information only and doesn't block app deployment."
      }
    },
    "description": {
      "type": "string",
      "defaultValue": "Description of the application"
    },
    "eula": {
      "type": "string",
      "defaultValue": ""
    },
    "privacyStatementUri": {
      "type": "string",
      "defaultValue": ""
    },
    "releaseNoteUri": {
      "type": "string",
      "defaultValue": ""
    },
    "mediaLink": {
      "type": "string"
    },
    "configLink": {
      "type": "string"
    },
    "appConfigFileName": {
      "type": "string"
    },
    "appPackageFileName": {
      "type": "string"
    },
    "replicaRegion1": {
      "type": "string",
      "defaultValue": "East US"
    },
    "replicaRegion2": {
      "type": "string",
      "defaultValue": "South Central US"
    },
    "installScript": {
      "type": "string",
      "metadata": {
        "description": "Optional. Script to run to install the application. Example: echo 'Installing application...'"
      }
    },
    "updateScript": {
      "type": "string",
      "metadata": {
        "description": "Optional. Script to run to update the application. Example: echo 'Updating application...'"
      }
    },
    "removeScript": {
      "type": "string",
      "metadata": {
        "description": "Optional. Script to run to delete the application. Example: echo 'Deleting application...'"
      }
    },
    "storageAccountType": {
      "type": "string",
      "allowedValues": ["PremiumV2_LRS", "Premium_LRS", "Standard_LRS", "Standard_ZRS"],
      "defaultValue": "Standard_LRS"
    }
  },
  "resources": [
    {
      "type": "Microsoft.Compute/galleries",
      "apiVersion": "2024-03-03",
      "name": "[parameters('galleryName')]",
      "location": "[parameters('location')]",
      "properties": {
        "identifier": {}
      }
    },
    {
      "type": "Microsoft.Compute/galleries/applications",
      "apiVersion": "2024-03-03",
      "name": "[format('{0}/{1}', parameters('galleryName'), parameters('applicationName'))]",
      "location": "[parameters('location')]",
      "dependsOn": [
        "[resourceId('Microsoft.Compute/galleries', parameters('galleryName'))]"
      ],
      "properties": {
        "supportedOSType": "[parameters('supportedOSType')]",
        "endOfLifeDate": "[parameters('endOfLifeDate')]",
        "description": "[parameters('description')]",
        "eula": "[if(equals(parameters('eula'), ''), json('null'), parameters('eula'))]",
        "privacyStatementUri": "[if(equals(parameters('privacyStatementUri'), ''), json('null'), parameters('privacyStatementUri'))]",
        "releaseNoteUri": "[if(equals(parameters('releaseNoteUri'), ''), json('null'), parameters('releaseNoteUri'))]"
      }
    },
    {
      "type": "Microsoft.Compute/galleries/applications/versions",
      "apiVersion": "2024-03-03",
      "name": "[format('{0}/{1}/{2}', parameters('galleryName'), parameters('applicationName'), parameters('versionName'))]",
      "location": "[parameters('location')]",
      "dependsOn": [
        "[resourceId('Microsoft.Compute/galleries/applications', parameters('galleryName'), parameters('applicationName'))]"
      ],
      "properties": {
        "publishingProfile": {
          "source": {
            "mediaLink": "[parameters('mediaLink')]",
            "defaultConfigurationLink": "[parameters('configLink')]"
          },
          "manageActions": {
            "install": "[parameters('installScript')]",
            "remove": "[parameters('removeScript')]",
            "update": "[parameters('updateScript')]"
          },
          "settings": {
            "scriptBehaviorAfterReboot": "Rerun",
            "configFileName": "[parameters('appConfigFileName')]",
            "packageFileName": "[parameters('appPackageFileName')]"
          },
          "targetRegions": [
            {
              "name": "[parameters('location')]",
              "regionalReplicaCount": 3,
              "storageAccountType": "[parameters('storageAccountType')]"
            },
            {
              "name": "[parameters('replicaRegion1')]",
              "regionalReplicaCount": 1,
              "storageAccountType": "[parameters('storageAccountType')]"
            },
            {
              "name": "[parameters('replicaRegion2')]"
            },
          ],
          "excludeFromLatest": false,
          "replicaCount": 2,
          "storageAccountType": "[parameters('storageAccountType')]"
        },
        "safetyProfile": {
          "allowDeletionOfReplicatedLocations": true
        },
        "endOfLifeDate": "[parameters('endOfLifeDate')]"
      }
    }
  ]
}

Distribuire le app per le macchine virtuali

È ora possibile fare riferimento a una o più applicazioni della macchina virtuale nel applicationProfile della macchina virtuale di Azure o dei set di scalabilità di macchine virtuali di Azure. Azure quindi esegue il pull del payload dell'applicazione vm e lo installa in ogni macchina virtuale usando lo script di installazione fornito. La proprietà definisce l'ordine sequenziale in cui vengono installate le applicazioni di macchine virtuali nella macchina virtuale.

Per altre informazioni su ogni proprietà, vedere lo schema del profilo applicazione della macchina virtuale/set di scalabilità di macchine virtuali.

  • Modello
  • REST
  • CLI
  • PowerShell
  • Portale

Usare il modello ARM seguente per distribuire l'Applicazione VM su Azure VM o su Set di macchine virtuali di Azure (Azure Virtual Machine Scale Sets). Questo modello illustra le proprietà chiave e le opzioni di configurazione per la distribuzione dell'applicazione vm.

Distribuire l'applicazione della macchina virtuale nei set di scalabilità di macchine virtuali

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "vmssName": {
      "type": "string"
    },
    "location": {
      "type": "string"
    },
    "subscriptionId": {
      "type": "string"
    },
    "resourceGroupName": {
      "type": "string"
    },
    "galleryName": {
      "type": "string"
    },
    "applicationName1": {
      "type": "string"
    },
    "applicationVersion1": {
      "type": "string",
      "defaultValue": "latest"
    },
    "configurationReference1": {
      "type": "string",
      "metadata": {
        "description": "Optional path to configuration file from Storage Account. Overrides default configuration file."
      }
    },
    "applicationName2": {
      "type": "string"
    },
    "applicationVersion2": {
      "type": "string",
      "defaultValue": "latest"
    }
  },
  "variables": {
    "packageReferenceId1": "[format('/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.Compute/galleries/{2}/applications/{3}/versions/{4}', parameters('subscriptionId'), parameters('resourceGroupName'), parameters('galleryName'), parameters('applicationName1'), parameters('applicationVersion1'))]",
    "packageReferenceId2": "[format('/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.Compute/galleries/{2}/applications/{3}/versions/{4}', parameters('subscriptionId'), parameters('resourceGroupName'), parameters('galleryName'), parameters('applicationName2'), parameters('applicationVersion2'))]"
  },
  "resources": [
    {
      "type": "Microsoft.Compute/virtualMachineScaleSets",
      "apiVersion": "2024-03-03",
      "name": "[parameters('vmssName')]",
      "location": "[parameters('location')]",
      "properties": {
        "virtualMachineProfile": {
          "applicationProfile": {
            "galleryApplications": [
              {
                "order": 1,
                "packageReferenceId": "[variables('packageReferenceId1')]",
                "configurationReference": "[parameters('configurationReference1')]",
                "treatFailureAsDeploymentFailure": true
              },
              {
                "order": 2,
                "packageReferenceId": "[variables('packageReferenceId2')]",
                "treatFailureAsDeploymentFailure": false
              }
            ]
          }
        }
      }
    }
  ]
}

Distribuire l'applicazione VM sulla macchina virtuale Azure

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "vmName": {
      "type": "string"
    },
    "location": {
      "type": "string"
    },
    "subscriptionId": {
      "type": "string"
    },
    "resourceGroupName": {
      "type": "string"
    },
    "galleryName": {
      "type": "string"
    },
    "applicationName1": {
      "type": "string"
    },
    "applicationVersion1": {
      "type": "string",
      "defaultValue": "latest"
    },
    "configurationReference1": {
      "type": "string",
      "metadata": {
        "description": "Optional path to configuration blob for application 1"
      }
    },
    "applicationName2": {
      "type": "string"
    },
    "applicationVersion2": {
      "type": "string",
      "defaultValue": "latest"
    }
  },
  "variables": {
    "packageReferenceId1": "[format('/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.Compute/galleries/{2}/applications/{3}/versions/{4}', parameters('subscriptionId'), parameters('resourceGroupName'), parameters('galleryName'), parameters('applicationName1'), parameters('applicationVersion1'))]",
    "packageReferenceId2": "[format('/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.Compute/galleries/{2}/applications/{3}/versions/{4}', parameters('subscriptionId'), parameters('resourceGroupName'), parameters('galleryName'), parameters('applicationName2'), parameters('applicationVersion2'))]"
  },
  "resources": [
    {
      "type": "Microsoft.Compute/virtualMachines",
      "apiVersion": "2024-07-01",
      "name": "[parameters('vmName')]",
      "location": "[parameters('location')]",
      "properties": {
        "applicationProfile": {
          "galleryApplications": [
            {
              "order": 1,
              "packageReferenceId": "[variables('packageReferenceId1')]",
              "configurationReference": "[parameters('configurationReference1')]",
              "treatFailureAsDeploymentFailure": true
            },
            {
              "order": 2,
              "packageReferenceId": "[variables('packageReferenceId2')]",
              "treatFailureAsDeploymentFailure": false
            }
          ]
        }
      }
    }
  ]
}

Passaggi successivi

  • Last updated on