Usare gli script di distribuzione nei modelli di Resource Manager

  • Articolo

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.

Suggerimento

È consigliabile Bicep perché offre le stesse funzionalità dei modelli di ARM e la sintassi è più semplice da usare. Per altre informazioni, vedere Script di distribuzione.

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.

Importante

Il servizio script di distribuzione richiede due risorse di supporto per l'esecuzione di script e la risoluzione dei problemi: un account di archiviazione e un'istanza del contenitore. È possibile specificare un account di archiviazione esistente. In caso contrario, il servizio script ne crea uno automaticamente. Le due risorse di supporto create automaticamente vengono in genere eliminate dal servizio script quando l'esecuzione dello script di distribuzione diventa in uno stato terminale. Vengono addebitate le risorse di supporto fino a quando non vengono eliminate. Per informazioni sui prezzi, vedere Prezzi di Istanze di Container e Prezzi di Archiviazione di Azure. Per altre informazioni, vedere Pulire le risorse dello script di distribuzione.

Nota

La logica di ripetizione dei tentativi per l'accesso ad Azure è ora incorporata nello script wrapper. Se si concedono autorizzazioni nello stesso modello degli script di distribuzione, il servizio script di distribuzione ritenta l'accesso per 10 minuti con intervallo di 10 secondi fino alla replica dell'assegnazione di ruolo dell'identità gestita.

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à 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 in questo elenco.
    • Passare le credenziali dell'entità servizio come variabili di ambiente sicure e quindi chiamare Connessione-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/01234567-89AB-CDEF-0123-456789ABCDEF/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"
  }
}

Nota

L'esempio è a scopo dimostrativo. Le proprietà scriptContent e primaryScriptUri non possono coesistere in un modello.

Nota

ScriptContent mostra uno script con più righe. La pipeline portale di Azure e Azure DevOps non possono analizzare uno script di distribuzione con più righe. È possibile concatenare i comandi di PowerShell (usando punti e virgola o \r\n o \n) in una riga oppure usare la primaryScriptUri proprietà con un file di script esterno. Sono disponibili molti strumenti di escape/unescape stringa JSON gratuiti. Ad esempio: https://www.freeformatter.com/json-escape.html.

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 Connessione-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 viene specificato, viene creato automaticamente un account di archiviazione. 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 consentito di esecuzione dello script specificato 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à viene utilizzata quando cleanupPreference è impostata 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"
    }
  }
}

Nota

Poiché gli script di distribuzione inline sono racchiusi tra virgolette doppie, le stringhe all'interno degli script di distribuzione devono essere precedute da un carattere di escape usando una barra rovesciata (\) o racchiuse tra virgolette singole. È anche possibile prendere in considerazione l'uso della sostituzione di stringhe come illustrato nell'esempio JSON precedente.

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:

Screenshot dell'output hello world dello script di distribuzione del modello di Resource Manager.

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, Archiviazione V2
    Standard_GZRS StorageV2
    Standard_LRS Archiviazione, Archiviazione V2
    Standard_RAGRS Archiviazione, Archiviazione V2
    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.

  • Archiviazione regole del firewall dell'account 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.

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.

Uso delle variabili di ambiente

Lo script di distribuzione usa queste variabili di ambiente:

Variabile di ambiente Valore predefinito Riservata per il sistema
AZ_SCRIPTS_AZURE_ENVIRONMENT AzureCloud N
AZ_SCRIPTS_CLEANUP_PREFERENCE OnExpiration N
AZ_SCRIPTS_OUTPUT_PATH <>AZ_SCRIPTS_PATH_OUTPUT_DIRECTORY/<AZ_SCRIPTS_PATH_SCRIPT_OUTPUT_FILE_NAME> Y
AZ_SCRIPTS_PATH_INPUT_DIRECTORY /mnt/azscripts/azscriptinput Y
AZ_SCRIPTS_PATH_OUTPUT_DIRECTORY /mnt/azscripts/azscriptoutput Y
AZ_SCRIPTS_PATH_U edizione Standard R_SCRIPT_FILE_NAME Azure PowerShell: userscript.ps1; Interfaccia della riga di comando di Azure: userscript.sh Y
AZ_SCRIPTS_PATH_PRIMARY_SCRIPT_URI_FILE_NAME primaryscripturi.config Y
AZ_SCRIPTS_PATH_SUPPORTING_SCRIPT_URI_FILE_NAME supportscripturi.config Y
AZ_SCRIPTS_PATH_SCRIPT_OUTPUT_FILE_NAME scriptoutputs.json Y
AZ_SCRIPTS_PATH_EXECUTION_RESULTS_FILE_NAME executionresult.json Y
AZ_SCRIPTS_U edizione Standard R_ASSIGNED_IDENTITY /subscriptions/ N

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.

Screenshot dei nomi delle risorse dello script di distribuzione del modello di Resource Manager.

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, la risorsa viene elencata nel gruppo di risorse nel portale di Azure. Lo screenshot seguente mostra la pagina Panoramica di una risorsa script di distribuzione:

Screenshot della panoramica del portale dello script di distribuzione del modello di Resource Manager.

La pagina di panoramica visualizza alcune informazioni importanti della risorsa, ad esempio stato di provisioning, account 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:

L'output Get-AzDeploymentScript è simile al seguente:

Name                : runPowerShellInlineWithOutput
Id                  : /subscriptions/01234567-89AB-CDEF-0123-456789ABCDEF/resourceGroups/myds0618rg/providers/Microsoft.Resources/deploymentScripts/runPowerShellInlineWithOutput
ResourceGroupName   : myds0618rg
Location            : centralus
SubscriptionId      : 01234567-89AB-CDEF-0123-456789ABCDEF
ProvisioningState   : Succeeded
Identity            : /subscriptions/01234567-89AB-CDEF-0123-456789ABCDEF/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/01234567-89AB-CDEF-0123-456789ABCDEF/resourceGroups/myds0618rg/providers/Microsoft.Storage/storageAccounts/ftnlvo6rlrvo2azscripts
ContainerInstanceId : /subscriptions/01234567-89AB-CDEF-0123-456789ABCDEF/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:

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/01234567-89AB-CDEF-0123-456789ABCDEF/resourceGroups/myds0624rg/providers/Microsoft.Resources/deploymentScripts/runBashWithOutputs",
    "identity": {
      "tenantId": "01234567-89AB-CDEF-0123-456789ABCDEF",
      "type": "userAssigned",
      "userAssignedIdentities": {
        "/subscriptions/01234567-89AB-CDEF-0123-456789ABCDEF/resourcegroups/myidentity/providers/Microsoft.ManagedIdentity/userAssignedIdentities/myuami": {
          "clientId": "01234567-89AB-CDEF-0123-456789ABCDEF",
          "principalId": "01234567-89AB-CDEF-0123-456789ABCDEF"
        }
      }
    },
    "kind": "AzureCLI",
    "location": "centralus",
    "name": "runBashWithOutputs",
    "outputs": {
      "Result": [
        {
          "id": "/subscriptions/01234567-89AB-CDEF-0123-456789ABCDEF/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/01234567-89AB-CDEF-0123-456789ABCDEF/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/01234567-89AB-CDEF-0123-456789ABCDEF/resourcegroups/myrg/providers/microsoft.resources/deploymentScripts/myDeployementScript?api-version=2020-10-01

L'output è simile a:

{
  "kind": "AzurePowerShell",
  "identity": {
    "type": "userAssigned",
    "tenantId": "01234567-89AB-CDEF-0123-456789ABCDEF",
    "userAssignedIdentities": {
      "/subscriptions/01234567-89AB-CDEF-0123-456789ABCDEF/resourceGroups/myidentity1008rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/myuami": {
        "principalId": "01234567-89AB-CDEF-0123-456789ABCDEF",
        "clientId": "01234567-89AB-CDEF-0123-456789ABCDEF"
      }
    }
  },
  "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/01234567-89AB-CDEF-0123-456789ABCDEF/resourceGroups/myds0624rg/providers/Microsoft.ContainerInstance/containerGroups/64lxews2qfa5uazscripts",
      "storageAccountId": "/subscriptions/01234567-89AB-CDEF-0123-456789ABCDEF/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/01234567-89AB-CDEF-0123-456789ABCDEF/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:

Screenshot dello script di distribuzione del modello di Resource Manager con l'opzione Mostra tipi nascosti nel portale.

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.

Nota

Non è consigliabile usare l'account di archiviazione e l'istanza del contenitore generate dal servizio script per altri scopi. Le due risorse potrebbero essere rimosse a seconda del ciclo di vita dello script.

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.

Nota

Scrivere script di distribuzione idempotenti. In questo modo viene garantito che, in caso di esecuzione accidentale, non provochino modifiche al sistema. Ad esempio, se si usa lo script di distribuzione per creare una risorsa di Azure, verificare che la risorsa non esista prima di crearla, in modo che lo script abbia esito positivo o la risorsa non venga creata nuovamente.

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

Codice errore Descrizione
DeploymentScriptInvalidOperation La definizione della risorsa dello script di distribuzione nel modello contiene nomi di proprietà non validi.
DeploymentScriptResourceConflict Non è possibile eliminare una risorsa script di distribuzione in stato non determiniale e l'esecuzione non ha superato 1 ora. In alternativa, non è possibile rieseguire lo stesso script di distribuzione con lo stesso identificatore di risorsa (stessa sottoscrizione, nome del gruppo di risorse e nome della risorsa) ma contenuto del corpo dello script diverso contemporaneamente.
DeploymentScriptOperationFailed L'operazione script di distribuzione non è riuscita internamente. Contattare il supporto tecnico Microsoft.
DeploymentScript Archiviazione AccountAccessKeyNotSpecified La chiave di accesso non è stata specificata per l'account di archiviazione esistente.
DeploymentScriptContainerGroupContainsInvalidContainers Un gruppo di contenitori creato dal servizio script di distribuzione è stato modificato esternamente e sono stati aggiunti contenitori non validi.
DeploymentScriptContainerGroupInNonterminalState Due o più risorse dello script di distribuzione usano lo stesso nome dell'istanza del contenitore di Azure nello stesso gruppo di risorse e uno di essi non ha ancora completato l'esecuzione.
DeploymentScript Archiviazione AccountInvalidKind L'account di archiviazione esistente del tipo BlobBlob Archiviazione o BLOB Archiviazione non supporta le condivisioni file e non può essere usato.
DeploymentScript Archiviazione AccountInvalidKindAndSku L'account di archiviazione esistente non supporta le condivisioni file. Per un elenco dei tipi di account di archiviazione supportati, vedere Usare l'account di archiviazione esistente.
DeploymentScript Archiviazione AccountNotFound L'account di archiviazione non esiste o è stato eliminato da un processo o uno strumento esterno.
DeploymentScript Archiviazione AccountWithServiceEndpointEnabled L'account di archiviazione specificato ha un endpoint di servizio. Un account di archiviazione con un endpoint di servizio non è supportato.
DeploymentScript Archiviazione AccountInvalidAccessKey Chiave di accesso non valida specificata per l'account di archiviazione esistente.
DeploymentScript Archiviazione AccountInvalidAccessKeyFormat Formato della chiave dell'account di archiviazione non valido. Vedere Gestire le chiavi di accesso dell'account di archiviazione.
DeploymentScriptExceededMaxAllowedTime Il tempo di esecuzione dello script di distribuzione ha superato il valore di timeout specificato nella definizione della risorsa dello script di distribuzione.
DeploymentScriptInvalidOutputs L'output dello script di distribuzione non è un oggetto JSON valido.
DeploymentScriptContainerInstancesServiceLoginFailure L'identità gestita assegnata dall'utente non è riuscita ad accedere dopo 10 tentativi con intervallo di 1 minuto.
DeploymentScriptContainerGroupNotFound Un gruppo di contenitori creato dal servizio script di distribuzione è stato eliminato da uno strumento o un processo esterno.
DeploymentScriptDownloadFailure Impossibile scaricare uno script di supporto. Vedere Usare lo script di supporto.
DeploymentScriptError Lo script utente ha generato un errore.
DeploymentScriptBootstrapScriptExecutionFailed Lo script bootstrap ha generato un errore. Lo script bootstrap è lo script di sistema che orchestra l'esecuzione dello script di distribuzione.
DeploymentScriptExecutionFailed Errore sconosciuto durante l'esecuzione dello script di distribuzione.
DeploymentScriptContainerInstancesServiceUnavailable Quando si crea l'istanza di Contenitore di Azure, ACI ha generato un errore di servizio non disponibile.
DeploymentScriptContainerGroupInNonterminalState Quando si crea l'istanza del contenitore di Azure, un altro script di distribuzione usa lo stesso nome ACI nello stesso ambito (stessa sottoscrizione, nome del gruppo di risorse e nome della risorsa).
DeploymentScriptContainerGroupNameInvalid Il nome dell'istanza del contenitore di Azure specificato non soddisfa i requisiti ACI. Vedere Risolvere i problemi comuni in Istanze di Azure Container.

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 identity proprietà . 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 nelle reti virtuali e dagli indirizzi IP selezionati.

      Screenshot della configurazione dell'account di archiviazione per l'accesso alla rete privata.

    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:

Esercitazione: Usare gli script di distribuzione nei modelli di Azure Resource Manager

Modulo Learn: Estendere i modelli di Resource Manager usando gli script di distribuzione