Usare gli script di distribuzione nei modelli di Resource Manager

Informazioni su come usare gli script di distribuzione nei modelli di Azure Resource Manager (ARM). Con la deploymentScripts risorsa, gli utenti possono eseguire script nelle distribuzioni arm ed esaminare i risultati dell'esecuzione.

Questi script possono essere usati per eseguire passaggi personalizzati, ad esempio:

• Aggiungere utenti a una directory.
• Eseguire operazioni del piano dati, ad esempio, copiare BLOB o database di inizializzazione.
• Cercare e convalidare un codice di licenza.
• Creare un certificato autofirmato.
• Creare un oggetto in Microsoft Entra ID.
• Cercare blocchi di indirizzi IP dal sistema personalizzato.

I vantaggi dello script di distribuzione:

• Semplifica la scrittura di codice, l'uso e l'esecuzione del debug. È possibile sviluppare script di distribuzione negli ambienti di sviluppo preferiti. Gli script possono essere incorporati in modelli o in file di script esterni.
• È possibile specificare la piattaforma e il linguaggio dello script. Attualmente gli script di distribuzione di Azure PowerShell e dell'interfaccia della riga di comando di Azure nell'ambiente Linux sono supportati.
• Consente di specificare gli argomenti della riga di comando da passare allo script.
• Può specificare gli output dello script e passarli nuovamente alla distribuzione.

La risorsa script di distribuzione è disponibile solo nelle aree in cui è disponibile l'istanza di contenitore di Azure. Vedere Disponibilità di risorse per Istanze di Azure Container nelle aree di Azure. Attualmente, lo script di distribuzione usa solo la rete pubblica.

Risorse di formazione

Se si preferisce ottenere informazioni sugli script di distribuzione tramite istruzioni dettagliate, vedere Estendere i modelli di Resource Manager usando gli script di distribuzione.

Configurare le autorizzazioni minime

Per l'API dello script di distribuzione versione 2020-10-01 o successiva, esistono due entità coinvolte nell'esecuzione dello script di distribuzione:

• Entità di distribuzione (l'entità usata per distribuire il modello): questa entità viene usata per creare le risorse sottostanti necessarie per l'esecuzione della risorsa script di distribuzione, ovvero un account di archiviazione e un'istanza del contenitore di Azure. Per configurare le autorizzazioni con privilegi minimi, assegnare un ruolo personalizzato con le proprietà seguenti all'entità di distribuzione:

  {
    "roleName": "deployment-script-minimum-privilege-for-deployment-principal",
    "description": "Configure least privilege for the deployment principal in deployment script",
    "type": "customRole",
    "IsCustom": true,
    "permissions": [
      {
        "actions": [
          "Microsoft.Storage/storageAccounts/*",
          "Microsoft.ContainerInstance/containerGroups/*",
          "Microsoft.Resources/deployments/*",
          "Microsoft.Resources/deploymentScripts/*"
        ],
      }
    ],
    "assignableScopes": [
      "[subscription().id]"
    ]
  }
  

  Se il Archiviazione di Azure e i provider di risorse dell'istanza di Azure Container non sono stati registrati, è necessario aggiungere Microsoft.Storage/register/action e Microsoft.ContainerInstance/register/action.

• Entità script di distribuzione: questa entità è necessaria solo se lo script di distribuzione deve eseguire l'autenticazione in Azure e chiamare l'interfaccia della riga di comando di Azure/PowerShell. Esistono due modi per specificare l'entità di sicurezza script di distribuzione:

  • Specificare un'identità gestita assegnata dall'utente nella identity proprietà (vedere Modelli di esempio). Se specificato, il servizio script chiama Connect-AzAccount -Identity prima di richiamare lo script di distribuzione. L'identità gestita deve avere l'accesso necessario per completare l'operazione nello script. Attualmente, per la proprietà è supportata solo l'identità identity gestita assegnata dall'utente. Per accedere con un'identità diversa, usare il secondo metodo qui elencato.
  • Passare le credenziali dell'entità servizio come variabili di ambiente sicure e quindi chiamare Connect-AzAccount o az login nello script di distribuzione.

  Se si usa un'identità gestita, l'entità di distribuzione richiede il ruolo Operatore identità gestita (un ruolo predefinito) assegnato alla risorsa di identità gestita.

Modelli di esempio

Il codice JSON seguente è un esempio. Per altre informazioni, vedere lo schema del modello più recente.

{
  "type": "Microsoft.Resources/deploymentScripts",
  "apiVersion": "2020-10-01",
  "name": "runPowerShellInline",
  "location": "[resourceGroup().location]",
  "tags": {
    "tagName1": "tagValue1",
    "tagName2": "tagValue2"
  },
  "kind": "AzurePowerShell", // or "AzureCLI"
  "identity": {
    "type": "userAssigned",
    "userAssignedIdentities": {
      "/subscriptions/aaaabbbb-0000-cccc-1111-dddd2222eeee/resourceGroups/myResourceGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/myID": {}
    }
  },
  "properties": {
    "forceUpdateTag": "1",
    "containerSettings": {
      "containerGroupName": "mycustomaci"
    },
    "storageAccountSettings": {
      "storageAccountName": "myStorageAccount",
      "storageAccountKey": "myKey"
    },
    "azPowerShellVersion": "9.7",  // or "azCliVersion": "2.47.0",
    "arguments": "-name \\\"John Dole\\\"",
    "environmentVariables": [
      {
        "name": "UserName",
        "value": "jdole"
      },
      {
        "name": "Password",
        "secureValue": "jDolePassword"
      }
    ],
    "scriptContent": "
      param([string] $name)
      $output = 'Hello {0}. The username is {1}, the password is {2}.' -f $name,${Env:UserName},${Env:Password}
      Write-Output $output
      $DeploymentScriptOutputs = @{}
      $DeploymentScriptOutputs['text'] = $output
    ", // or "primaryScriptUri": "https://raw.githubusercontent.com/Azure/azure-docs-json-samples/master/deployment-script/deploymentscript-helloworld.ps1",
    "supportingScriptUris":[],
    "timeout": "PT30M",
    "cleanupPreference": "OnSuccess",
    "retentionInterval": "P1D"
  }
}

Dettagli sui valori delle proprietà:

• identity: per l'API dello script di distribuzione versione 2020-10-01 o successiva, un'identità gestita assegnata dall'utente è facoltativa, a meno che non sia necessario eseguire azioni specifiche di Azure nello script. Per l'API versione 2019-10-01-preview, è necessaria un'identità gestita perché il servizio script di distribuzione lo usa per eseguire gli script. Quando si specifica la proprietà Identity, il servizio script chiama Connect-AzAccount -Identity prima di richiamare lo script utente. Attualmente è supportata solo l'Identità gestita assegnata dall'utente di Azure. Per accedere con un'identità diversa, è possibile chiamare Connect-AzAccount nello script.

• tags: tag di script di distribuzione. Se il servizio script di distribuzione genera un account di archiviazione e un'istanza del contenitore, i tag vengono passati a entrambe le risorse, che possono essere usate per identificarle. Un altro modo per identificare queste risorse consiste nell'usare i relativi suffissi, che contengono "azscripts". Per altre informazioni, vedere Monitorare e risolvere i problemi relativi agli script di distribuzione.

• kind: specificare il tipo di script. Attualmente sono supportati gli script di Azure PowerShell e dell'interfaccia della riga di comando di Azure. I valori sono AzurePowerShell e AzureCLI.

• forceUpdateTag: la modifica di questo valore tra distribuzioni di modelli forza l'esecuzione dello script di distribuzione. Se si usano le newGuid() funzioni o , entrambe le utcNow() funzioni possono essere usate solo nel valore predefinito per un parametro. Per altre informazioni, vedere Eseguire lo script più di una volta.

• containerSettings: specificare le impostazioni per personalizzare l'istanza di Azure Container. Lo script di distribuzione richiede una nuova istanza di Azure Container. Non è possibile specificare un'istanza di Azure Container esistente. Tuttavia, è possibile personalizzare il nome del gruppo di contenitori usando containerGroupName. Se non specificato, il nome del gruppo viene generato automaticamente.

• storageAccountSettings: Specificare le impostazioni per l'uso di un account di archiviazione esistente. Se storageAccountName non è specificato, l’account di archiviazione viene creato automaticamente. Vedere Usare un account di archiviazione esistente.

• azPowerShellVersion/azCliVersion: specificare la versione del modulo da usare. Vedere un elenco delle versioni di Azure PowerShell supportate. La versione determina l'immagine del contenitore da usare:

  • La versione az successiva o uguale a 9 usa Ubuntu 22.04.
  • Az versione maggiore o uguale a 6, ma minore di 9 usa Ubuntu 20.04.
  • Az versione precedente a 6 usa Ubuntu 18.04.

  Importante

  È consigliabile eseguire l'aggiornamento alla versione più recente di Ubuntu, perché Ubuntu 18.04 sta per scadere e non riceverà più gli aggiornamenti della sicurezza oltre il 31 maggio 2023.

  Vedere un elenco delle versioni supportate dell'interfaccia della riga di comando di Azure.

  Importante

  Lo script di distribuzione usa le immagini dell'interfaccia della riga di comando disponibili da Registro Contenitori Microsoft .Deployment scripts uses the available CLI images from Microsoft Container Registry (MCR). In genere richiede circa un mese per certificare un'immagine dell'interfaccia della riga di comando per lo script di distribuzione. Non usare le versioni dell'interfaccia della riga di comando rilasciate negli ultimi 30 giorni. Per trovare le date di rilascio delle immagini, vedere Note sulla versione dell'interfaccia della riga di comando di Azure. Se viene usata una versione non supportata, il messaggio di errore elenca le versioni supportate.

• arguments: specificare i valori del parametro. I valori sono separati da uno spazio.

  Gli script di distribuzione suddivide gli argomenti in una matrice di stringhe richiamando la chiamata di sistema CommandLineToArgvW . Questo passaggio è necessario perché gli argomenti vengono passati come proprietà di comando all'istanza di Azure Container e la proprietà del comando è una matrice di stringhe.

  Se gli argomenti contengono caratteri di escape, usare JsonEscaper per eseguire un doppio escape dei caratteri. Incollare la stringa di escape originale nello strumento e quindi selezionare Escape. Lo strumento restituisce una stringa con escape doppia. Ad esempio, nel modello di esempio precedente, l'argomento è -name \"John Dole\". La stringa di escape è -name \\\"John Dole\\\".

  Per passare un parametro di modello di Resource Manager di tipo object come argomento, convertire l'oggetto in una stringa usando la funzione string() e quindi usare la funzione replace() per sostituire qualsiasi \" oggetto in \\\". Ad esempio:

  replace(string(parameters('tables')), '\"', '\\\"')
  

  Per altre informazioni, vedere il modello di esempio.

• environmentVariables: specificare le variabili di ambiente da passare allo script. Per altre informazioni, vedere Sviluppare script di distribuzione.

• scriptContent: specificare il contenuto dello script. Per eseguire uno script esterno, usare primaryScriptUri. Per esempi, vedere Usare script inline e Usare script esterni.

• primaryScriptUri: Specificare un URL accessibile pubblicamente per lo script di distribuzione primario con estensioni di file supportate. Per altre informazioni, vedere Usare script esterni.

• supportingScriptUris: Specificare una matrice di URL accessibili pubblicamente per supportare i file che vengono chiamati in scriptContent o primaryScriptUri. Per altre informazioni, vedere Usare script esterni.

• timeout: specificare il tempo massimo di esecuzione dello script consentito nel formato ISO 8601. Il valore predefinito è P1D.

• cleanupPreference. Specificare la preferenza di pulire le due risorse di distribuzione di supporto, l'account di archiviazione e l'istanza del contenitore, quando l'esecuzione dello script diventa in uno stato terminale. L'impostazione predefinita è Always, ovvero l'eliminazione delle risorse di supporto nonostante lo stato del terminale (Succeeded, Failed, Canceled). Per altre informazioni, vedere Pulire le risorse dello script di distribuzione.

• retentionInterval: Specificare l'intervallo per il quale il servizio conserva la risorsa script di distribuzione dopo che l'esecuzione dello script di distribuzione raggiunge uno stato terminale. La risorsa script di distribuzione viene eliminata alla scadenza di questa durata. La durata è basata sul modello ISO 8601. L'intervallo di conservazione è compreso tra 1 e 26 ore (PT26H). Questa proprietà si utilizza quando cleanupPreference è impostato su OnExpiration. Per altre informazioni, vedere Pulire le risorse dello script di distribuzione.

Altri esempi

• Esempio 1: creare un insieme di credenziali delle chiavi e usare lo script di distribuzione per assegnare un certificato all'insieme di credenziali delle chiavi.
• Esempio 2: creare un gruppo di risorse a livello di sottoscrizione, creare un insieme di credenziali delle chiavi nel gruppo di risorse e quindi usare lo script di distribuzione per assegnare un certificato all'insieme di credenziali delle chiavi.
• Esempio 3: creare un'identità gestita assegnata dall'utente, assegnare il ruolo di collaboratore all'identità a livello di gruppo di risorse, creare un insieme di credenziali delle chiavi e quindi usare lo script di distribuzione per assegnare un certificato all'insieme di credenziali delle chiavi.
• Esempio 4: è lo stesso scenario dell'esempio 1 in questo elenco. Viene creato un nuovo gruppo di risorse per eseguire lo script di distribuzione. Questo modello è un modello a livello di sottoscrizione.
• Esempio 5: è lo stesso scenario dell'esempio 4. Questo modello è un modello a livello di gruppo di risorse.
• Esempio 6: creare manualmente un'identità gestita assegnata dall'utente e assegnarla l'autorizzazione per usare l'API Microsoft Graph per creare applicazioni Microsoft Entra. Nel modello arm usare uno script di distribuzione per creare un'applicazione Microsoft Entra e un'entità servizio e restituire gli ID oggetto e l'ID client.

Usare script inline

Il modello seguente include una risorsa definita con il tipo Microsoft.Resources/deploymentScripts. La parte evidenziata è lo script inline.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "name": {
      "type": "string",
      "defaultValue": "\\\"John Dole\\\""
    },
    "utcValue": {
      "type": "string",
      "defaultValue": "[utcNow()]"
    }
  },
  "resources": [
    {
      "type": "Microsoft.Resources/deploymentScripts",
      "apiVersion": "2020-10-01",
      "name": "runPowerShellInlineWithOutput",
      "location": "[resourceGroup().location]",
      "kind": "AzurePowerShell",
      "properties": {
        "forceUpdateTag": "[parameters('utcValue')]",
        "azPowerShellVersion": "8.3",
        "scriptContent": "
          param([string] $name)
          $output = \"Hello {0}\" -f $name
          Write-Output $output
          $DeploymentScriptOutputs = @{}
          $DeploymentScriptOutputs['text'] = $output
        ",
        "arguments": "[concat('-name', ' ', parameters('name'))]",
        "timeout": "PT1H",
        "cleanupPreference": "OnSuccess",
        "retentionInterval": "P1D"
      }
    }
  ],
  "outputs": {
    "result": {
      "value": "[reference('runPowerShellInlineWithOutput').outputs.text]",
      "type": "string"
    }
  }
}

Lo script richiede un parametro e genera l'output del valore del parametro. DeploymentScriptOutputs viene usato per l'archiviazione degli output. Nella sezione value output la riga mostra come accedere ai valori archiviati. Write-Output è usato a scopo di debug. Per informazioni su come accedere al file di output, vedere Monitorare e risolvere i problemi relativi agli script di distribuzione. Per le descrizioni delle proprietà, vedere Modelli di esempio.

Per eseguire lo script, selezionare Prova per aprire Cloud Shell e quindi incollare il codice seguente nel riquadro della shell.

$resourceGroupName = Read-Host -Prompt "Enter the name of the resource group to be created"
$location = Read-Host -Prompt "Enter the location (i.e. centralus)"

New-AzResourceGroup -Name $resourceGroupName -Location $location

New-AzResourceGroupDeployment -ResourceGroupName $resourceGroupName -TemplateUri "https://raw.githubusercontent.com/Azure/azure-docs-json-samples/master/deployment-script/deploymentscript-helloworld.json"

Write-Host "Press [ENTER] to continue ..."

L'output sarà simile al seguente:

Usare script esterni

Oltre agli script inline, è anche possibile usare file di script esterni. Sono supportati solo gli script di PowerShell primari con l'estensione di file ps1. Per gli script dell'interfaccia della riga di comando, gli script primari possono avere estensioni (o senza estensione), purché gli script siano script Bash validi. Per usare file di script esterni, sostituire scriptContent con primaryScriptUri. Ad esempio:

"primaryScriptUri": "https://raw.githubusercontent.com/Azure/azure-docs-json-samples/master/deployment-script/deploymentscript-helloworld.ps1",

Per altre informazioni, vedere il modello di esempio.

I file di script esterni devono essere accessibili. Per proteggere i file di script archiviati negli account di archiviazione di Azure, generare un token di firma di accesso condiviso e includerlo nell'URI per il modello. Impostare l'ora di scadenza in modo da garantire un tempo sufficiente per completare la distribuzione. Per altre informazioni, vedere Distribuire un modello di Resource Manager privato con token di firma di accesso condiviso.

L'utente è responsabile di garantire l'integrità degli script a cui fa riferimento lo script di distribuzione, primaryScriptUri o supportingScriptUris. Fare riferimento solo a script attendibili.

Usare script di supporto

È possibile separare le logiche complesse in uno o più file di script di supporto. Se necessario, la proprietà supportingScriptUris consente di fornire una matrice di URI ai file di script di supporto:

"scriptContent": "
    ...
    ./Create-Cert.ps1
    ...
"

"supportingScriptUris": [
  "https://raw.githubusercontent.com/Azure/azure-docs-json-samples/master/deployment-script/create-cert.ps1"
],

I file script di supporto possono essere chiamati sia da script inline che da file di script primari. I file di script di supporto non prevedono alcuna restrizione sull'estensione di file.

I file di supporto vengono copiati azscripts/azscriptinput in in fase di esecuzione. Usare il percorso relativo per fare riferimento ai file di supporto da script inline e file di script primari.

Usare gli output degli script di PowerShell

Il modello seguente illustra come passare valori tra due deploymentScripts risorse:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "name": {
      "type": "string",
      "defaultValue": "John Dole"
    },
    "utcValue": {
      "type": "string",
      "defaultValue": "[utcNow()]"
    }
  },
  "resources": [
    {
      "type": "Microsoft.Resources/deploymentScripts",
      "apiVersion": "2020-10-01",
      "name": "scriptInTemplate1",
      "location": "[resourceGroup().location]",
      "kind": "AzurePowerShell",
      "properties": {
        "forceUpdateTag": "[parameters('utcValue')]",
        "azPowerShellVersion": "8.3",
        "timeout": "PT1H",
        "arguments": "[concat('-name', ' ', concat('\\\"', parameters('name'), '\\\"'))]",
        "scriptContent": "
          param([string] $name)
          $output = 'Hello {0}' -f $name
          Write-Output $output
          $DeploymentScriptOutputs = @{}
          $DeploymentScriptOutputs['text'] = $output
        ",
        "cleanupPreference": "Always",
        "retentionInterval": "P1D"
      }
    },
    {
      "type": "Microsoft.Resources/deploymentScripts",
      "apiVersion": "2020-10-01",
      "name": "scriptInTemplate2",
      "location": "[resourceGroup().location]",
      "kind": "AzurePowerShell",
      "dependsOn": [
        "scriptInTemplate1"
      ],
      "properties": {
        "forceUpdateTag": "[parameters('utcValue')]",
        "azPowerShellVersion": "8.3",
        "timeout": "PT1H",
        "arguments": "[concat('-textToEcho', ' ', concat('\\\"', reference('scriptInTemplate1').outputs.text, '\\\"'))]",
        "scriptContent": "
          param([string] $textToEcho)
          Write-Output $textToEcho
          $DeploymentScriptOutputs = @{}
          $DeploymentScriptOutputs['text'] = $textToEcho
        ",
        "cleanupPreference": "Always",
        "retentionInterval": "P1D"
      }
    }
  ],
  "outputs": {
    "result": {
      "value": "[reference('scriptInTemplate2').outputs.text]",
      "type": "string"
    }
  }
}

Nella prima risorsa si definisce una variabile denominata $DeploymentScriptOutputse la si usa per archiviare i valori di output. Per accedere al valore di output da un'altra risorsa all'interno del modello, usare:

reference('<ResourceName>').outputs.text

Usare gli output degli script dell'interfaccia della riga di comando

A differenza degli script di distribuzione di Azure PowerShell, l'interfaccia della riga di comando/bash non espone una variabile comune per l'archiviazione degli output degli script. Usa invece una variabile di ambiente denominata AZ_SCRIPTS_OUTPUT_PATH per indicare il percorso del file di output dello script. Quando si esegue uno script di distribuzione all'interno di un modello di Resource Manager, la shell Bash configura automaticamente questa variabile di ambiente. Il valore predefinito è impostato su /mnt/azscripts/azscriptoutput/scriptoutputs.json. Gli output sono necessari per essere conformi a una struttura di oggetti stringa JSON valida. Il contenuto del file deve essere formattato come coppia chiave-valore. Ad esempio, una matrice di stringhe deve essere salvata come { "MyResult": [ "foo", "bar"] }. L'archiviazione solo dei risultati della matrice, ad esempio [ "foo", "bar" ], è considerata non valida.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "identity": {
      "type": "string"
    },
    "utcValue": {
      "type": "string",
      "defaultValue": "[utcNow()]"
    }
  },
  "resources": [
    {
      "type": "Microsoft.Resources/deploymentScripts",
      "apiVersion": "2020-10-01",
      "name": "runBashWithOutputs",
      "location": "[resourceGroup().location]",
      "kind": "AzureCLI",
      "identity": {
        "type": "UserAssigned",
        "userAssignedIdentities": {
          "[parameters('identity')]": {
          }
        }
      },
      "properties": {
        "forceUpdateTag": "[parameters('utcValue')]",
        "AzCliVersion": "2.40.0",
        "timeout": "PT30M",
        "arguments": "'foo' 'bar'",
        "environmentVariables": [
          {
            "name": "UserName",
            "value": "jdole"
          },
          {
            "name": "Password",
            "secureValue": "jDolePassword"
          }
        ],
        "scriptContent": "result=$(az keyvault list); echo \"arg1 is: $1\"; echo \"arg2 is: $2\"; echo \"Username is: $UserName\"; echo \"password is: $Password\"; echo $result | jq -c '{Result: map({id: .id})}' > $AZ_SCRIPTS_OUTPUT_PATH",
        "cleanupPreference": "OnExpiration",
        "retentionInterval": "P1D"

Nell'esempio precedente viene usato jq. Viene fornito con le immagini del contenitore. Vedere Configurare l'ambiente di sviluppo.

Usare l'account di archiviazione esistente

Per l'esecuzione e la risoluzione dei problemi degli script sono necessari un account di archiviazione e un'istanza di contenitore. Sono disponibili le opzioni per specificare un account di archiviazione esistente. In caso contrario, l'account di archiviazione e l'istanza di contenitore vengono creati automaticamente dal servizio script. Requisiti per l'uso di un account di archiviazione esistente:

• I tipi di account di archiviazione supportati sono:

  SKU	Tipo supportato
  Premium_LRS	FileStorage
  Premium_ZRS	FileStorage
  Standard_GRS	Archiviazione, ArchiviazioneV2
  Standard_GZRS	StorageV2
  Standard_LRS	Archiviazione, ArchiviazioneV2
  Standard_RAGRS	Archiviazione, ArchiviazioneV2
  Standard_RAGZRS	StorageV2
  Standard_ZRS	StorageV2

  Queste combinazioni supportano condivisioni di file. Per altre informazioni, vedere Creare una condivisione file di Azure e Tipi di account di archiviazione.

• Le regole del firewall dell'account di archiviazione non sono ancora supportate. Per altre informazioni, vedere Configurare i firewall e le reti virtuali di Archiviazione di Azure.

• L'entità di distribuzione deve disporre delle autorizzazioni per gestire l'account di archiviazione, che include le condivisioni file di lettura, creazione ed eliminazione.

• La proprietà allowSharedKeyAccess dell'account di archiviazione deve essere impostata su true. L'unico modo per montare un account di archiviazione nell'istanza del contenitore di Azure (ACI) consiste nell’usare una chiave di accesso.

Per specificare un account di archiviazione esistente, aggiungere il codice JSON seguente all'elemento property di Microsoft.Resources/deploymentScripts:

"storageAccountSettings": {
  "storageAccountName": "myStorageAccount",
  "storageAccountKey": "myKey"
},

• storageAccountName: specificare il nome dell'account di archiviazione.

• storageAccountKey: specificare una delle chiavi dell'account di archiviazione. È possibile usare la funzione listKeys() per recuperare la chiave. Ad esempio:

  "storageAccountSettings": {
      "storageAccountName": "[variables('storageAccountName')]",
      "storageAccountKey": "[listKeys(resourceId('Microsoft.Storage/storageAccounts', variables('storageAccountName')), '2019-06-01').keys[0].value]"
  }
  

Vedere Modelli di esempio per un esempio di definizione di Microsoft.Resources/deploymentScripts completo.

Quando viene usato un account di archiviazione esistente, il servizio script crea una condivisione file con un nome univoco. Vedere Pulire le risorse dello script di distribuzione per informazioni su come il servizio script pulisce la condivisione file.

Sviluppare script di distribuzione

Gestire gli errori non determini

È possibile controllare la risposta di PowerShell agli errori non determinibili usando la $ErrorActionPreference variabile nello script di distribuzione. Se la variabile non è impostata nello script di distribuzione, il servizio script usa il valore predefinito Continua.

Il servizio script imposta lo stato di provisioning delle risorse su Failed quando lo script rileva un errore nonostante l'impostazione di $ErrorActionPreference.

Usa le variabili di ambiente

Lo script di distribuzione usa queste variabili di ambiente:

Per altre informazioni sull'uso AZ_SCRIPTS_OUTPUT_PATHdi , vedere Usare output dallo script dell'interfaccia della riga di comando.

Passare stringhe protette allo script di distribuzione

L'impostazione delle variabili di ambiente (EnvironmentVariable) nelle istanze di contenitore consente di offrire la configurazione dinamica dell'applicazione o dello script eseguiti dal contenitore. Lo script di distribuzione gestisce variabili di ambiente non protette e protette nello stesso modo di Istanza di Azure Container. Per altre informazioni, vedere Impostare variabili di ambiente in istanze di contenitore. Per un esempio, vedere Modelli di esempio.

La dimensione massima consentita per le variabili di ambiente è di 64 KB.

Monitorare e risolvere i problemi degli script di distribuzione

Il servizio script crea un account di archiviazione (a meno che non si specifichi un account di archiviazione esistente) e un'istanza di contenitore per l'esecuzione dello script. Se queste risorse vengono create automaticamente dal servizio script, entrambe le risorse hanno il azscripts suffisso nei nomi delle risorse.

Lo script utente, i risultati dell'esecuzione e il file stdout vengono archiviati nelle condivisioni file dell'account di archiviazione. Esiste una cartella denominata azscripts. Nella cartella sono presenti altre due cartelle per l'input e i file di output: azscriptinput e azscriptoutput.

La cartella di output contiene un file executionresult.json e il file di output dello script. È possibile visualizzare il messaggio di errore dell'esecuzione dello script in executionresult.json. Il file di output viene creato solo quando lo script viene eseguito correttamente. La cartella di input contiene un file di script di sistema di PowerShell e i file di script di distribuzione dell'utente. È possibile sostituire il file di script di distribuzione dell'utente con uno modificato ed eseguire nuovamente lo script di distribuzione dall'istanza di contenitore di Azure.

Usare il portale di Azure

Dopo aver distribuito una risorsa script di distribuzione, essa viene elencata nel gruppo di risorse nel portale di Azure. Lo screenshot seguente mostra la pagina Panoramica di una risorsa script di distribuzione:

Nella pagina di panoramica vengono visualizzate alcune informazioni importanti della risorsa, ad esempio stato di provisioning, account di archiviazione, istanza del contenitore e log.

Dal menu a sinistra è possibile visualizzare il contenuto dello script di distribuzione, gli argomenti passati allo script e l'output. È anche possibile esportare un modello per lo script di distribuzione, incluso lo script di distribuzione.

Utilizzare PowerShell

Con Azure PowerShell è possibile gestire gli script di distribuzione nell'ambito della sottoscrizione o del gruppo di risorse:

• Get-AzDeploymentScript: ottiene o elenca gli script di distribuzione.
• Get-AzDeploymentScriptLog: ottiene il log di un'esecuzione di script di distribuzione.
• Remove-AzDeploymentScript: rimuove uno script di distribuzione e le risorse associate.
• Save-AzDeploymentScriptLog: salva il log dell'esecuzione di uno script di distribuzione su disco.

L'output Get-AzDeploymentScript è simile al seguente:

Name                : runPowerShellInlineWithOutput
Id                  : /subscriptions/aaaabbbb-0000-cccc-1111-dddd2222eeee/resourceGroups/myds0618rg/providers/Microsoft.Resources/deploymentScripts/runPowerShellInlineWithOutput
ResourceGroupName   : myds0618rg
Location            : centralus
SubscriptionId      : aaaabbbb-0000-cccc-1111-dddd2222eeee
ProvisioningState   : Succeeded
Identity            : /subscriptions/aaaabbbb-0000-cccc-1111-dddd2222eeee/resourceGroups/mydentity1008rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/myuami
ScriptKind          : AzurePowerShell
AzPowerShellVersion : 9.7
StartTime           : 5/11/2023 7:46:45 PM
EndTime             : 5/11/2023 7:49:45 PM
ExpirationDate      : 5/12/2023 7:49:45 PM
CleanupPreference   : OnSuccess
StorageAccountId    : /subscriptions/aaaabbbb-0000-cccc-1111-dddd2222eeee/resourceGroups/myds0618rg/providers/Microsoft.Storage/storageAccounts/ftnlvo6rlrvo2azscripts
ContainerInstanceId : /subscriptions/aaaabbbb-0000-cccc-1111-dddd2222eeee/resourceGroups/myds0618rg/providers/Microsoft.ContainerInstance/containerGroups/ftnlvo6rlrvo2azscripts
Outputs             :
                      Key                 Value
                      ==================  ==================
                      text                Hello John Dole

RetentionInterval   : P1D
Timeout             : PT1H

Utilizzare l'interfaccia della riga di comando di Azure

Usando l'interfaccia della riga di comando di Azure, è possibile gestire gli script di distribuzione nell'ambito della sottoscrizione o del gruppo di risorse:

• az deployment-scripts delete: eliminare uno script di distribuzione.
• az deployment-scripts list: elencare tutti gli script di distribuzione.
• az deployment-scripts show: recuperare uno script di distribuzione.
• az deployment-scripts show-log: mostrare i log degli script di distribuzione.

L'output del comando list è simile al seguente:

[
  {
    "arguments": "'foo' 'bar'",
    "azCliVersion": "2.40.0",
    "cleanupPreference": "OnExpiration",
    "containerSettings": {
      "containerGroupName": null
    },
    "environmentVariables": null,
    "forceUpdateTag": "20231101T163748Z",
    "id": "/subscriptions/aaaabbbb-0000-cccc-1111-dddd2222eeee/resourceGroups/myds0624rg/providers/Microsoft.Resources/deploymentScripts/runBashWithOutputs",
    "identity": {
      "tenantId": "aaaabbbb-0000-cccc-1111-dddd2222eeee",
      "type": "userAssigned",
      "userAssignedIdentities": {
        "/subscriptions/aaaabbbb-0000-cccc-1111-dddd2222eeee/resourcegroups/myidentity/providers/Microsoft.ManagedIdentity/userAssignedIdentities/myuami": {
          "clientId": "00001111-aaaa-2222-bbbb-3333cccc4444",
          "principalId": "aaaabbbb-0000-cccc-1111-dddd2222eeee"
        }
      }
    },
    "kind": "AzureCLI",
    "location": "centralus",
    "name": "runBashWithOutputs",
    "outputs": {
      "Result": [
        {
          "id": "/subscriptions/aaaabbbb-0000-cccc-1111-dddd2222eeee/resourceGroups/mytest/providers/Microsoft.KeyVault/vaults/mykv1027",
          "resourceGroup": "mytest"
        }
      ]
    },
    "primaryScriptUri": null,
    "provisioningState": "Succeeded",
    "resourceGroup": "mytest",
    "retentionInterval": "1 day, 0:00:00",
    "scriptContent": "result=$(az keyvault list); echo \"arg1 is: $1\"; echo $result | jq -c '{Result: map({id: .id})}' > $AZ_SCRIPTS_OUTPUT_PATH",
    "status": {
      "containerInstanceId": "/subscriptions/aaaabbbb-0000-cccc-1111-dddd2222eeee/resourceGroups/mytest/providers/Microsoft.ContainerInstance/containerGroups/eg6n7wvuyxn7iazscripts",
      "endTime": "2023-11-01T16:39:12.080950+00:00",
      "error": null,
      "expirationTime": "2023-11-02T16:39:12.080950+00:00",
      "startTime": "2023-11-01T16:37:53.139700+00:00",
      "storageAccountId": null
    },
    "storageAccountSettings": {
      "storageAccountKey": null,
      "storageAccountName": "dsfruro267qwb4i"
    },
    "supportingScriptUris": null,
    "systemData": {
      "createdAt": "2023-10-31T19:06:57.060909+00:00",
      "createdBy": "someone@contoso.com",
      "createdByType": "User",
      "lastModifiedAt": "2023-11-01T16:37:51.859570+00:00",
      "lastModifiedBy": "someone@contoso.com",
      "lastModifiedByType": "User"
    },
    "tags": null,
    "timeout": "0:30:00",
    "type": "Microsoft.Resources/deploymentScripts"
  }
]

Usare l'API REST

È possibile ottenere le informazioni sulla distribuzione delle risorse dello script di distribuzione a livello di gruppo di risorse e a livello di sottoscrizione usando l'API REST:

/subscriptions/<SubscriptionID>/resourcegroups/<ResourceGroupName>/providers/microsoft.resources/deploymentScripts/<DeploymentScriptResourceName>?api-version=2020-10-01

/subscriptions/<SubscriptionID>/providers/microsoft.resources/deploymentScripts?api-version=2020-10-01

Nell'esempio seguente viene usato ARMClient:

armclient login
armclient get /subscriptions/aaaabbbb-0000-cccc-1111-dddd2222eeee/resourcegroups/myrg/providers/microsoft.resources/deploymentScripts/myDeployementScript?api-version=2020-10-01

L'output è simile a:

{
  "kind": "AzurePowerShell",
  "identity": {
    "type": "userAssigned",
    "tenantId": "aaaabbbb-0000-cccc-1111-dddd2222eeee",
    "userAssignedIdentities": {
      "/subscriptions/aaaabbbb-0000-cccc-1111-dddd2222eeee/resourceGroups/myidentity1008rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/myuami": {
        "principalId": "aaaabbbb-0000-cccc-1111-dddd2222eeee",
        "clientId": "00001111-aaaa-2222-bbbb-3333cccc4444"
      }
    }
  },
  "location": "centralus",
  "systemData": {
    "createdBy": "someone@contoso.com",
    "createdByType": "User",
    "createdAt": "2023-05-11T02:59:04.7501955Z",
    "lastModifiedBy": "someone@contoso.com",
    "lastModifiedByType": "User",
    "lastModifiedAt": "2023-05-11T02:59:04.7501955Z"
  },
  "properties": {
    "provisioningState": "Succeeded",
    "forceUpdateTag": "20220625T025902Z",
    "azPowerShellVersion": "9.7",
    "scriptContent": "\r\n          param([string] $name)\r\n          $output = \"Hello {0}\" -f $name\r\n          Write-Output $output\r\n          $DeploymentScriptOutputs = @{}\r\n          $DeploymentScriptOutputs['text'] = $output\r\n        ",
    "arguments": "-name \\\"John Dole\\\"",
    "retentionInterval": "P1D",
    "timeout": "PT1H",
    "containerSettings": {},
    "status": {
      "containerInstanceId": "/subscriptions/aaaabbbb-0000-cccc-1111-dddd2222eeee/resourceGroups/myds0624rg/providers/Microsoft.ContainerInstance/containerGroups/64lxews2qfa5uazscripts",
      "storageAccountId": "/subscriptions/aaaabbbb-0000-cccc-1111-dddd2222eeee/resourceGroups/myds0624rg/providers/Microsoft.Storage/storageAccounts/64lxews2qfa5uazscripts",
      "startTime": "2023-05-11T02:59:07.5951401Z",
      "endTime": "2023-05-11T03:00:16.7969234Z",
      "expirationTime": "2023-05-12T03:00:16.7969234Z"
    },
    "outputs": {
      "text": "Hello John Dole"
    },
    "cleanupPreference": "OnSuccess"
  },
  "id": "/subscriptions/aaaabbbb-0000-cccc-1111-dddd2222eeee/resourceGroups/myds0624rg/providers/Microsoft.Resources/deploymentScripts/runPowerShellInlineWithOutput",
  "type": "Microsoft.Resources/deploymentScripts",
  "name": "runPowerShellInlineWithOutput"
}

L'API REST seguente restituisce il log:

/subscriptions/<SubscriptionID>/resourcegroups/<ResourceGroupName>/providers/microsoft.resources/deploymentScripts/<DeploymentScriptResourceName>/logs?api-version=2020-10-01

Funziona solo prima che vengano eliminate le risorse dello script di distribuzione.

Per visualizzare la risorsa deploymentScripts nel portale, selezionare Mostra tipi nascosti:

Pulire le risorse dello script di distribuzione

Le due risorse di supporto create automaticamente non possono mai sopravvivere alla risorsa, a meno che non si verifichino errori durante l'eliminazione deploymentScript . Il ciclo di vita delle risorse di supporto è controllato dalla cleanupPreference proprietà , il ciclo di vita della deploymentScript risorsa è controllato dalla retentionInterval proprietà :

• cleanupPreference: specificare la preferenza di pulizia delle due risorse di supporto quando l'esecuzione dello script diventa in uno stato terminale. I valori supportati sono:

  • Sempre: eliminare le due risorse di supporto una volta che l'esecuzione dello script diventa in uno stato terminale. Se viene usato un account di archiviazione esistente, il servizio script elimina la condivisione file creata dal servizio. Poiché la deploymentScripts risorsa potrebbe essere ancora presente dopo la pulizia delle risorse di supporto, il servizio script rende persistenti i risultati dell'esecuzione dello script, ad esempio stdout, output e valore restituito prima dell'eliminazione delle risorse.

  • OnSuccess: eliminare le due risorse di supporto solo quando l'esecuzione dello script ha esito positivo. Se viene usato un account di archiviazione esistente, il servizio script rimuove la condivisione file solo quando l'esecuzione dello script ha esito positivo.

    Se l'esecuzione dello script non riesce, il servizio script attende fino alla retentionInterval scadenza prima di pulire le risorse di supporto e quindi la risorsa script di distribuzione.

  • OnExpiration: eliminare le due risorse di supporto solo quando l'impostazione retentionInterval è scaduta. Se viene usato un account di archiviazione esistente, il servizio script rimuove la condivisione file, ma mantiene l'account di archiviazione.

  L'istanza del contenitore e l'account cleanupPreferencedi archiviazione vengono eliminati in base a . Tuttavia, se lo script non riesce e cleanupPreference non è impostato su Always, il processo di distribuzione mantiene automaticamente il contenitore in esecuzione per un'ora o finché il contenitore non viene pulito. È possibile usare il tempo per risolvere i problemi dello script. Se si vuole mantenere il contenitore in esecuzione dopo le distribuzioni riuscite, aggiungere un passaggio di sospensione allo script. Ad esempio, aggiungere Start-Sleep alla fine dello script. Se non si aggiunge il passaggio di sospensione, il contenitore viene impostato su uno stato del terminale e non è possibile accedervi anche se non è ancora stato eliminato.

• retentionInterval: specificare l'intervallo di tempo che deploymentScript verrà conservato e dopo il quale una risorsa sarà scaduta ed eliminata.

L'account di archiviazione creato automaticamente e l'istanza del contenitore non possono essere eliminati se lo script di distribuzione viene distribuito in un gruppo di risorse con un blocco CanNotDelete. Per risolvere questo problema, è possibile distribuire lo script di distribuzione in un altro gruppo di risorse senza blocchi. Vedere Esempio 4 e Esempio 5 nei modelli di esempio.

Eseguire lo script più di una volta

L'esecuzione dello script di distribuzione è un'operazione idempotente. Se nessuna delle proprietà della deploymentScripts risorsa (incluso lo script inline) viene modificata, lo script non viene eseguito quando si ridistribuisce il modello. Il servizio script di distribuzione confronta i nomi delle risorse nel modello con le risorse esistenti nello stesso gruppo di risorse. Se si vuole eseguire lo stesso script di distribuzione più volte, sono disponibili due opzioni:

• Modificare il nome della risorsa deploymentScripts. Usare, ad esempio, la funzione di modello utcNow come nome della risorsa o come parte del nome della risorsa. La modifica del nome della risorsa crea una nuova risorsa deploymentScripts. È utile per mantenere una cronologia dell'esecuzione dello script.

  Nota

  La utcNow funzione può essere usata solo nel valore predefinito per un parametro.

• Specificare un valore diverso nella proprietà del modello forceUpdateTag. Ad esempio, usare utcNow come valore.

Configurare l'ambiente di sviluppo

È possibile usare un'immagine del contenitore preconfigurata come ambiente di sviluppo dello script di distribuzione. Per altre informazioni, vedere Configurare l'ambiente di sviluppo per gli script di distribuzione nei modelli.

Una volta testato correttamente lo script, è possibile usarlo come script di distribuzione nel modello.

Codici di errore dello script di distribuzione

Usare Microsoft Graph all'interno di uno script di distribuzione

Uno script di distribuzione può usare Microsoft Graph per creare e usare oggetti in Microsoft Entra ID.

Comandi

Quando si usano gli script di distribuzione dell'interfaccia della riga di comando di Azure, è possibile usare i comandi all'interno del gruppo di comandi az ad per usare applicazioni, entità servizio, gruppi e utenti. È anche possibile richiamare direttamente le API Microsoft Graph usando il comando az rest.

Quando si usano gli script di distribuzione di Azure PowerShell, è possibile usare il Invoke-RestMethod cmdlet per richiamare direttamente le API Microsoft Graph.

Autorizzazioni

L'identità usata dallo script di distribuzione deve essere autorizzata a lavorare con l'API Microsoft Graph, con le autorizzazioni appropriate per le operazioni eseguite. È necessario autorizzare l'identità all'esterno della distribuzione del modello, ad esempio tramite la creazione preliminare di un'identità gestita assegnata dall'utente e assegnandole un ruolo dell'app per Microsoft Graph. Per altre informazioni, vedere l'avvio rapido seguente .

Accedere alla rete virtuale privata

Con Microsoft.Resources/deploymentScripts versione 2023-08-01, è possibile eseguire script di distribuzione in reti private con alcune configurazioni aggiuntive.

• Creare un'identità gestita assegnata dall'utente e specificarla nella proprietà identity. Per assegnare l'identità, vedere Identità.

• Creare un account di archiviazione con allowSharedKeyAccess impostato su true e specificare lo script di distribuzione per usare l'account di archiviazione esistente. Per specificare un account di archiviazione esistente, vedere Usare un account di archiviazione esistente. Per l'account di archiviazione è necessaria una configurazione aggiuntiva.

  1. Aprire l'account di archiviazione nel portale di Azure.

  2. Nel menu a sinistra selezionare Controllo di accesso (IAM) e quindi selezionare la scheda Assegnazioni di ruolo.

  3. Aggiungere il Storage File Data Privileged Contributor ruolo all'identità gestita di assegnazione utente.

  4. Nel menu a sinistra, in Sicurezza e rete selezionare Rete e quindi firewall e reti virtuali.

  5. Selezionare Abilitato da reti virtuali e indirizzi IP selezionati.

     

  6. In Reti virtuali, aggiungere una subnet. Nello screenshot la subnet è denominata dspvnVnet.

  7. In Eccezioni, selezionare Consenti ai servizi di Azure nell'elenco dei servizi attendibili di accedere a questo account di archiviazione.

Il modello di Resource Manager seguente illustra come configurare l'ambiente per l'esecuzione di uno script di distribuzione:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "prefix": {
      "type": "string",
      "maxLength": 10
    },
    "location": {
      "type": "string",
      "defaultValue": "[resourceGroup().location]"
    },
    "userAssignedIdentityName": {
      "type": "string",
      "defaultValue": "[format('{0}Identity', parameters('prefix'))]"
    },
    "storageAccountName": {
      "type": "string",
      "defaultValue": "[format('{0}stg{1}', parameters('prefix'), uniqueString(resourceGroup().id))]"
    },
    "vnetName": {
      "type": "string",
      "defaultValue": "[format('{0}Vnet', parameters('prefix'))]"
    },
    "subnetName": {
      "type": "string",
      "defaultValue": "[format('{0}Subnet', parameters('prefix'))]"
    }
  },
  "resources": [
    {
      "type": "Microsoft.Network/virtualNetworks",
      "apiVersion": "2023-09-01",
      "name": "[parameters('vnetName')]",
      "location": "[parameters('location')]",
      "properties": {
        "addressSpace": {
          "addressPrefixes": [
            "10.0.0.0/16"
          ]
        },
        "enableDdosProtection": false,
        "subnets": [
          {
            "name": "[parameters('subnetName')]",
            "properties": {
              "addressPrefix": "10.0.0.0/24",
              "serviceEndpoints": [
                {
                  "service": "Microsoft.Storage"
                }
              ],
              "delegations": [
                {
                  "name": "Microsoft.ContainerInstance.containerGroups",
                  "properties": {
                    "serviceName": "Microsoft.ContainerInstance/containerGroups"
                  }
                }
              ]
            }
          }
        ]
      }
    },
    {
      "type": "Microsoft.Storage/storageAccounts",
      "apiVersion": "2023-01-01",
      "name": "[parameters('storageAccountName')]",
      "location": "[parameters('location')]",
      "sku": {
        "name": "Standard_LRS"
      },
      "kind": "StorageV2",
      "properties": {
        "networkAcls": {
          "bypass": "AzureServices",
          "virtualNetworkRules": [
            {
              "id": "[resourceId('Microsoft.Network/virtualNetworks/subnets', parameters('vnetName'), parameters('subnetName'))]",
              "action": "Allow",
              "state": "Succeeded"
            }
          ],
          "defaultAction": "Deny"
        },
        "allowSharedKeyAccess": true
      },
      "dependsOn": [
        "[resourceId('Microsoft.Network/virtualNetworks', parameters('vnetName'))]"
      ]
    },
    {
      "type": "Microsoft.ManagedIdentity/userAssignedIdentities",
      "apiVersion": "2023-07-31-preview",
      "name": "[parameters('userAssignedIdentityName')]",
      "location": "[parameters('location')]"
    },
    {
      "type": "Microsoft.Authorization/roleAssignments",
      "apiVersion": "2022-04-01",
      "scope": "[format('Microsoft.Storage/storageAccounts/{0}', parameters('storageAccountName'))]",
      "name": "[guid(tenantResourceId('Microsoft.Authorization/roleDefinitions', '69566ab7-960f-475b-8e7c-b3118f30c6bd'), resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', parameters('userAssignedIdentityName')), resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccountName')))]",
      "properties": {
        "principalId": "[reference(resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', parameters('userAssignedIdentityName')), '2023-07-31-preview').principalId]",
        "roleDefinitionId": "[tenantResourceId('Microsoft.Authorization/roleDefinitions', '69566ab7-960f-475b-8e7c-b3118f30c6bd')]",
        "principalType": "ServicePrincipal"
      },
      "dependsOn": [
        "[resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccountName'))]",
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', parameters('userAssignedIdentityName'))]"
      ]
    }
  ]
}

È possibile usare il modello di Resource Manager seguente per testare la distribuzione:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "prefix": {
      "type": "string"
    },
    "location": {
      "type": "string",
      "defaultValue": "[resourceGroup().location]"
    },
    "utcValue": {
      "type": "string",
      "defaultValue": "[utcNow()]"
    },
    "storageAccountName": {
      "type": "string"
    },
    "vnetName": {
      "type": "string"
    },
    "subnetName": {
      "type": "string"
    },
    "userAssignedIdentityName": {
      "type": "string"
    }
  },
  "resources": [
    {
      "type": "Microsoft.Resources/deploymentScripts",
      "apiVersion": "2023-08-01",
      "name": "[format('{0}DS', parameters('prefix'))]",
      "location": "[parameters('location')]",
      "identity": {
        "type": "userAssigned",
        "userAssignedIdentities": {
          "[format('{0}', resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', parameters('userAssignedIdentityName')))]": {}
        }
      },
      "kind": "AzureCLI",
      "properties": {
        "forceUpdateTag": "[parameters('utcValue')]",
        "azCliVersion": "2.47.0",
        "storageAccountSettings": {
          "storageAccountName": "[parameters('storageAccountName')]"
        },
        "containerSettings": {
          "subnetIds": [
            {
              "id": "[resourceId('Microsoft.Network/virtualNetworks/subnets', parameters('vnetName'), parameters('subnetName'))]"
            }
          ]
        },
        "scriptContent": "echo \"Hello world!\"",
        "retentionInterval": "P1D",
        "cleanupPreference": "OnExpiration"
      }
    }
  ]
}

Passaggi successivi

In questo articolo si è appreso come usare gli script di distribuzione. Per esaminare un'esercitazione relativa a uno script di distribuzione: