Utiliser des scripts de déploiement dans des modèles ARM

  • Article

Découvrez comment utiliser des scripts de déploiement dans des modèles Azure Resource Manager (ARM). Avec la ressource deploymentScripts, les utilisateurs peuvent exécuter des scripts dans des déploiements ARM et examiner les résultats d’exécution.

Conseil

Nous recommandons Bicep parce qu’il offre les mêmes fonctionnalités que les modèles ARM et que la syntaxe est plus facile d’utilisation. Pour plus d’informations, consultez Script de déploiement.

Ces scripts peuvent être utilisés pour effectuer des étapes personnalisées, comme :

  • Ajouter des utilisateurs à un annuaire ;
  • Effectuer des opérations de plan de données, par exemple, copier des objets blob ou alimenter une base de données ;
  • Rechercher et valider une clé de licence ;
  • Créez un certificat auto-signé.
  • Créer un objet dans Microsoft Entra ID
  • Rechercher des blocs d’adresses IP à partir du système personnalisé.

Les avantages du script de déploiement :

  • Facile à coder, utiliser et déboguer. Vous pouvez développer des scripts de déploiement dans vos environnements de développement préférés. Les scripts peuvent être incorporés aux modèles ou dans des fichiers de script externe.
  • Vous pouvez spécifier le langage de script et la plateforme. À l’heure actuelle, les scripts de déploiement Azure PowerShell et Azure CLI dans l’environnement Linux sont pris en charge.
  • Permet la transmission des arguments de ligne de commande au script.
  • Peut spécifier des sorties de script et les renvoyer au déploiement.

La ressource de script de déploiement n'est disponible que dans les régions où Azure Container Instance est disponible. Consultez Disponibilité des ressources pour Azure Container Instances dans les régions Azure. Actuellement, le script de déploiement utilise uniquement la mise en réseau publique.

Important

Le service de script de déploiement nécessite deux ressources complémentaires pour l’exécution et la résolution des problèmes de scripts : un compte de stockage et une instance de conteneur. Vous pouvez spécifier un compte de stockage existant. Sinon, le service de script en crée un pour vous. Les deux ressources complémentaires créées automatiquement sont généralement supprimées par le service de script quand l’exécution du script de déploiement arrive à un état terminal. Vous êtes facturé pour les ressources complémentaires jusqu’à ce qu’elles soient supprimées. Pour plus d’informations sur les prix, consultez Tarifs Container Instances et Tarifs Stockage Azure. Pour plus d’informations, consultez Nettoyer les ressources de script de déploiement.

Notes

La logique de nouvelle tentative pour la connexion à Azure est désormais intégrée au script wrapper. Si vous accordez des autorisations dans le même modèle que vos scripts de déploiement, le service de script de déploiement tente de se connecter pendant 10 minutes avec un intervalle de 10 secondes jusqu’à la réplication de l’attribution de rôle d’identité managée.

Ressources de formation

Si vous préférez découvrir les scripts de déploiement avec une aide pas à pas, consultez Étendre des modèles ARM à l’aide de scripts de déploiement.

Configurer les autorisations minimales

Pour l’API de script de déploiement version 2020-10-01 ou ultérieure, deux principaux sont impliqués dans l’exécution du script de déploiement :

  • Déploiement principal (principal utilisé pour le déploiement du modèle) : ce principal est utilisé pour créer des ressources sous-jacentes nécessaires à l’exécution de la ressource de script de déploiement : un compte de stockage et une instance de conteneur Azure. Pour configurer les autorisations de privilège minimum, affectez un rôle personnalisé avec les propriétés suivantes au principal de déploiement :

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

    Si le stockage Azure et les fournisseurs de ressources Azure Container Instance n’ont pas été inscrits, vous devez également ajouter Microsoft.Storage/register/action et Microsoft.ContainerInstance/register/action.

  • Principal du script de déploiement : ce principal est requis uniquement si le script de déploiement doit s’authentifier auprès d’Azure et appeler l’instance CLI Azure/PowerShell. Deux méthodes permettent de spécifier le principal du script de déploiement :

    • Spécifiez une identité managée affectée par l’utilisateur dans la identity propriété (voir exemples de modèles). Lorsqu’il est spécifié, le service de script appelle Connect-AzAccount -Identity avant d’appeler le script de déploiement. L’identité managée doit avoir l’accès requis pour terminer l’opération dans le script. Actuellement, seule l’identité managée affectée par l’utilisateur est prise en charge pour la propriété identity. Pour vous connecter avec une identité différente, utilisez la deuxième méthode de cette liste.
    • Transmettez les informations d’identification du principal de service en tant que variables d’environnement sécurisées, puis appelez Connecter-AzAccount ou az login dans le script de déploiement.

    Si une identité gérée est utilisée, le principal de déploiement a besoin du rôle Opérateur d’identités gérées (un rôle intégré) affecté à la ressource d’identité gérée.

Exemples de modèles

L’extrait JSON ci-dessous est un exemple. Pour plus d’informations, consultez la dernière version du schéma de modèle.

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

Notes

L’exemple ne sert qu’à des fins de démonstration. Les propriétés scriptContent et primaryScriptUri ne peuvent pas coexister dans un modèle.

Notes

La propriété scriptContent affiche un script de plusieurs lignes. Le portail Azure et le pipeline Azure DevOps ne peuvent pas analyser un script de déploiement de plusieurs lignes. Vous pouvez chaîner les commandes PowerShell (en utilisant des points-virgules ou \rn ou \n) en une seule ligne, ou utiliser la propriété primaryScriptUri avec un fichier de script externe. De nombreux outils gratuits d’échappement ou d’annulation d’échappement de chaîne JSON sont disponibles. Par exemple, https://www.freeformatter.com/json-escape.html.

Détails des valeurs de propriété :

  • identity : Pour l’API de script de déploiement version 2020-10-01 ou ultérieure, une identité managée attribuée par l’utilisateur est facultative, sauf si vous devez effectuer des actions spécifiques à Azure dans le script. Pour la version d’API 2019-10-01-preview, une identité managée est nécessaire, car le service de script de déploiement l’utilise pour exécuter les scripts. Lorsque la propriété d’identité est spécifiée, le service de script appelle Connect-AzAccount -Identity avant d’appeler le script utilisateur. Actuellement, seule l’identité managée affectée par l’utilisateur est prise en charge. Pour vous connecter avec une identité différente, vous pouvez appeler Connect-AzAccount dans le script.

  • tags : Balises de script de déploiement. Si le service de script de déploiement génère un compte de stockage et une instance de conteneur, les balises sont transmises aux deux ressources, qui peuvent être utilisées pour les identifier. Une autre façon d’identifier ces ressources consiste à utiliser leurs suffixes, qui contiennent des « azscripts ». Pour plus d’informations, consultez Surveiller et dépanner les scripts de déploiement.

  • kind : spécifie le type de script. Actuellement, les scripts Azure PowerShell et Azure CLI sont pris en charge. Les valeurs sont AzurePowerShell et AzureCLI.

  • forceUpdateTag : la modification de cette valeur entre les déploiements de modèle force le script de déploiement à s’exécuter de nouveau. Si vous utilisez les fonctions newGuid() ou utcNow(), ces deux fonctions ne peuvent être utilisées que dans la valeur par défaut d’un paramètre. Pour plus d’informations, consultez Exécuter le script plusieurs fois.

  • containerSettings : Spécifiez les paramètres pour personnaliser l’instance de conteneur Azure. Le script de déploiement nécessite une nouvelle instance de conteneur Azure. Vous ne pouvez pas spécifier une instance de conteneur Azure existante. Toutefois, vous pouvez personnaliser le nom du groupe de conteneurs en utilisant containerGroupName. S’il n’est pas spécifié, le nom du groupe est généré automatiquement.

  • storageAccountSettings: Spécifiez les paramètres pour utiliser un compte de stockage existant. Si storageAccountName n’est pas spécifié, un compte de stockage est créé automatiquement. Consultez Utiliser un compte de stockage existant.

  • azPowerShellVersion/azCliVersion : spécifie la version du module à utiliser. Consultez la liste des versions de Azure PowerShell prises en charge. La version détermine l’image conteneur à utiliser :

    • La version Az supérieure ou égale à 9 utilise Ubuntu 22.04.
    • La version Az supérieure ou égale à 6 mais inférieure à 9 utilise Ubuntu 20.04.
    • La version Az inférieure à 6 utilise Ubuntu 18.04.

    Important

    Il est recommandé de mettre à niveau vers la dernière version d’Ubuntu, car Ubuntu 18.04 arrive à sa fin de vie et ne recevra plus de mises à jour de sécurité au-delà du 31 mai 2023.

    Consultez la liste des versions de Azure CLI prises en charge.

    Important

    Le script de déploiement utilise les images CLI disponibles à partir de Microsoft Container Registry (MCR). La certification d’une image CLI pour un script de déploiement prend environ un mois. N’utilisez pas les versions de l’interface CLI qui ont été publiées il y a moins de 30 jours. Pour trouver les dates de publication des images, consultez les Notes de publication d’Azure CLI. Si une version non prise en charge est utilisée, le message d’erreur répertorie les versions prises en charge.

  • arguments : Spécifiez les valeurs de paramètre. Les valeurs sont séparées par des espaces.

    Les scripts de déploiement divisent les arguments en un tableau de chaînes en effectuant l’appel système CommandLineToArgvW. Cette étape est nécessaire, car les arguments sont transmis en tant que propriétés de commande à Azure Container Instance et la propriété de commande est un tableau de chaîne.

    Si les arguments contiennent des caractères d’échappement, utilisez JsonEscaper pour double-placer les caractères. Collez votre chaîne d’échappement d’origine dans l’outil, puis sélectionnez Échappement. L’outil génère une chaîne avec deux séquences d’échappement. Par exemple, dans l’exemple de modèle précédent, l’argument est -name \"John Dole\". La chaîne placée dans une séquence d’échappement est -name \\\"John Dole\\\".

    Pour passer un paramètre de modèle ARM d’objet type en tant qu’argument, convertissez l’objet en chaîne à l’aide de la fonction chaîne(), puis utilisez la fonction remplacer() pour remplacer tout \" en \\\". Par exemple :

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

    Pour plus d’informations, consultez l’exemple de modèle.

  • environmentVariables : spécifie les variables d'environnement à transmettre au script. Pour plus d'informations, consultez Développer des scripts de déploiement.

  • scriptContent : précise le contenu du script. Pour exécuter un script externe, utilisez plutôt primaryScriptUri. Pour obtenir des exemples, consultez Utiliser un script inclus et Utiliser un script externe.

  • primaryScriptUri : spécifiez une URL accessible publiquement pour le script de déploiement principal avec les extensions de fichier prises en charge. Pour plus d’informations, consultez Utiliser des scripts externes.

  • primaryScriptUri : spécifiez un tableau d’URL accessibles publiquement pour les fichiers de support qui seront appelés dans supportingScriptUris ou scriptContent. Pour plus d’informations, consultez Utiliser des scripts externes.

  • timeout : précise la durée d’exécution maximale autorisée du script, définie au format ISO 8601. La valeur par défaut est P1D.

  • cleanupPreference. Spécifiez la préférence de nettoyage des deux ressources de déploiement complémentaires, du compte de stockage et de l’instance de conteneur quand l’exécution du script arrive à un état terminal. Le paramètre par défaut est Always, ce qui signifie que les ressources complémentaires sont supprimées malgré l’état terminal (Succeeded, Failed, Canceled). Pour plus d’informations, consultez Nettoyer les ressources de script de déploiement.

  • retentionInterval : Spécifie l’intervalle pendant lequel le service conserve la ressource du script de déploiement quand l’exécution du script arrive à un état terminal. La ressource du script de déploiement est supprimée à la fin de cette période. La durée est basée sur le modèle ISO 8601. L’intervalle de rétention est compris entre 1 et 26 heures (PT26H). Cette propriété est utilisée quand cleanupPreference a la valeur OnExpiration. Pour plus d’informations, consultez Nettoyer les ressources de script de déploiement.

Autres exemples

  • Exemple 1 : créez un coffre de clés et utiliser le script de déploiement pour affecter un certificat au coffre de clés.
  • Exemple 2 : créez un groupe de ressources au niveau de l’abonnement, créez un coffre de clés dans le groupe de ressources, puis utilisez le script de déploiement pour affecter un certificat au coffre de clés.
  • Exemple 3 : créez une identité gérée affectée par l’utilisateur, attribuez le rôle collaborateur à l’identité au niveau du groupe de ressources, créez un coffre de clés, puis utilisez le script de déploiement pour affecter un certificat au coffre de clés.
  • Exemple 4 : il s’agit du même scénario que l’Exemple 1 dans cette liste. Un nouveau groupe de ressources est créé pour exécuter le script de déploiement. Ce modèle est un modèle de niveau d’abonnement.
  • Exemple 5 : il s’agit du même scénario que l’Exemple 4. Ce modèle est un modèle de niveau groupe de ressources.
  • Exemple 6 : créez manuellement une identité managée affectée par l’utilisateur et attribuez-lui l’autorisation d’utiliser l’API Microsoft Graph pour créer des applications Microsoft Entra. Dans le modèle ARM, utilisez un script de déploiement pour créer une application et un principal de service Microsoft Entra et générer les ID d’objet et l’ID client.

Utiliser des scripts inclus

Le modèle suivant dispose d’une ressource définie avec le type Microsoft.Resources/deploymentScripts. La partie en surbrillance est le script inclus.

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

Notes

Étant donné que les scripts de déploiement inclus sont placés entre guillemets doubles, les chaînes contenues dans les scripts de déploiement doivent être échappées à l’aide d’une barre oblique inverse (\) ou mises entre guillemets simples. Vous pouvez également envisager d’utiliser la substitution de chaîne, comme montré dans l’exemple JSON précédent.

Le script accepte un paramètre, et génère la valeur du paramètre. DeploymentScriptOutputs s’utilise pour stocker les sorties. À la section outputs, la ligne value montre comment accéder aux valeurs stockées. Write-Output s’utilise pour le débogage. Pour savoir comment accéder au fichier de sortie, consultez Analyser et résoudre les problèmes des scripts de déploiement. Pour obtenir les descriptions des propriétés, consultez Exemples de modèles.

Afin d’exécuter le script, sélectionnez Try it (Essayer) pour ouvrir Cloud Shell, puis collez le code suivant dans le volet de l’interpréteur de commandes.

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

Le résultat se présente ainsi :

Capture d’écran de la sortie hello world du script de déploiement du modèle Resource Manager.

Utiliser des scripts externes

En plus des scripts inclus, vous pouvez utiliser des fichiers de script externe. Seuls les scripts PowerShell principaux dotés de l’extension de fichier ps1 sont pris en charge. Pour les scripts CLI, les scripts principaux peuvent avoir n’importe quelle extension (ou n’avoir aucune extension), à condition que les scripts soient des scripts Bash valides. Pour utiliser les fichiers de script externe, remplacez scriptContent par primaryScriptUri. Par exemple :

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

Pour plus d’informations, consultez l’exemple de modèle.

Les fichiers de script externe doivent être accessibles. Pour sécuriser vos fichiers de script stockés dans des comptes de stockage Azure, générez un jeton SAP et incluez-le dans l’URI du modèle. Définissez le délai d’expiration de façon à laisser suffisamment de temps pour terminer le déploiement. Pour plus d’informations, consultez Déployer un modèle privé ARM avec un jeton SAP.

Vous êtes chargé de garantir l'intégrité des scripts référencés par le script de déploiement, à savoir primaryScriptUri ou supportingScriptUris. Référencez uniquement les scripts auxquels vous faites confiance.

Utiliser des scripts de prise en charge

Vous pouvez séparer les logiques complexes en un ou plusieurs fichiers de script de prise en charge. La propriété supportingScriptUris vous permet de fournir un tableau d’URI pour les fichiers de script de prise en charge, le cas échéant :

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

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

Les fichiers de script de prise en charge peuvent être appelés à partir de scripts inclus et de fichiers de script principal. Les fichiers de script de prise en charge n’ont aucune restriction quant à l’extension de fichier.

Les fichiers de prise en charge sont copiés dans azscripts/azscriptinput au moment de l’exécution. Utilisez un chemin relatif pour référencer les fichiers de prise en charge à partir de scripts inclus et de fichiers de script principal.

Utiliser les sorties des scripts PowerShell

Le modèle suivant montre comment passer des valeurs entre deux ressources deploymentScripts :

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

Dans la première ressource, vous définissez une variable appelée $DeploymentScriptOutputs et l’utilisez pour stocker les valeurs de sortie. Pour accéder à la valeur de sortie à partir d’une autre ressource dans le modèle, utilisez :

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

Utiliser les sorties des scripts CLI

Contrairement aux scripts de déploiement Azure PowerShell, CLI/bash n’expose pas de variable commune pour le stockage des sorties de script. Au lieu de cela, il utilise une variable d’environnement nommée AZ_SCRIPTS_OUTPUT_PATH pour indiquer l’emplacement du fichier de sorties de script. Lors de l’exécution d’un script de déploiement dans un modèle ARM, l’interpréteur de commandes Bash configure automatiquement cette variable d’environnement pour vous. Sa valeur prédéfinie est définie avec /mnt/azscripts/azscriptoutput/scriptoutputs.json. Les sorties doivent se conformer à une structure d’objet de chaîne JSON valide. Le contenu du fichier doit être mis sous la forme d’une paire clé-valeur. Par exemple, un tableau de chaînes doit être enregistré sous { "MyResult": [ "foo", "bar"] }. Le stockage uniquement des résultats du tableau, tels que [ "foo", "bar" ], est considéré comme non valide.

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

jq est utilisé dans l’exemple précédent. Il est fourni avec les images conteneurs. Consultez Configurer l’environnement de développement.

Utiliser un compte de stockage existant

Un compte de stockage et une instance de conteneur sont nécessaires pour l’exécution et la résolution des problèmes d’un script. Vous avez le choix entre les options pour spécifier un compte de stockage existant ; sinon, le compte de stockage et l’instance de conteneur sont automatiquement créés par le service de script. Exigences requises pour l’utilisation d’un compte de stockage existant :

  • Les types de comptes de stockage pris en charge sont les suivants :

    SKU Genre pris en charge
    Premium_LRS FileStorage
    Premium_ZRS FileStorage
    Standard_GRS Storage, StorageV2
    Standard_GZRS StorageV2
    Standard_LRS Storage, StorageV2
    Standard_RAGRS Storage, StorageV2
    Standard_RAGZRS StorageV2
    Standard_ZRS StorageV2

    Ces combinaisons prennent en charge les partages de fichiers. Pour plus d’informations, consultezCrée un partage de fichiers Azure et Types de compte de stockage.

  • Les règles de pare-feu de compte de stockage ne sont pas encore prises en charge. Pour plus d’informations, consultez Configurer Pare-feu et réseaux virtuels dans Stockage Azure.

  • Le principal de déploiement doit avoir les autorisations nécessaires pour gérer le compte de stockage, y compris la lecture, la création et la suppression des partages de fichiers.

Pour spécifier un compte de stockage existant, ajoutez le code JSON suivant à l’élément de propriété de Microsoft.Resources/deploymentScripts :

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

  • storageAccountName : spécifiez le nom du compte de stockage.

  • storageAccountKey : spécifiez l’une des clés de compte de stockage. Vous pouvez utiliser la fonction listKeys() pour récupérer la clé. Par exemple :

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

Consultez Exemples de modèles pour obtenir un exemple complet de la définition Microsoft.Resources/deploymentScripts.

Lorsqu’un compte de stockage existant est utilisé, le service de script crée un partage de fichiers avec un nom unique. Pour savoir comment le service de script nettoie le partage de fichiers, consultez Nettoyer les ressources de script de déploiement.

Développer des scripts de déploiement

Gérer les erreurs sans fin d’exécution

Vous pouvez contrôler la façon dont PowerShell répond aux erreurs sans fin d’exécution à l’aide de la variable $ErrorActionPreference dans votre script de déploiement. Si la variable n’est pas définie dans votre script de déploiement, le service de script utilise la valeur par défaut Continuer.

Le service de script définit l’état d’approvisionnement de la ressource sur Échec quand le script rencontre une erreur malgré le paramètre $ErrorActionPreference.

Utiliser des variables d’environnement

Le script de déploiement utilise ces variables d’environnement :

Variable d’environnement Valeur par défaut Réservé au système
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> O
AZ_SCRIPTS_PATH_INPUT_DIRECTORY /mnt/azscripts/azscriptinput O
AZ_SCRIPTS_PATH_OUTPUT_DIRECTORY /mnt/azscripts/azscriptoutput O
AZ_SCRIPTS_PATH_USER_SCRIPT_FILE_NAME Azure PowerShell : userscript.ps1 ; Azure CLI : userscript.sh O
AZ_SCRIPTS_PATH_PRIMARY_SCRIPT_URI_FILE_NAME primaryscripturi.config O
AZ_SCRIPTS_PATH_SUPPORTING_SCRIPT_URI_FILE_NAME supportingscripturi.config O
AZ_SCRIPTS_PATH_SCRIPT_OUTPUT_FILE_NAME scriptoutputs.json O
AZ_SCRIPTS_PATH_EXECUTION_RESULTS_FILE_NAM executionresult.json O
AZ_SCRIPTS_USER_ASSIGNED_IDENTITY /subscriptions/ N

Pour plus d’informations sur l’utilisation de AZ_SCRIPTS_OUTPUT_PATH, consultez Utiliser des sorties à partir de scripts de déploiement.

Passer des chaînes sécurisées au script de déploiement

La définition de variables d'environnement (EnvironmentVariable) dans vos instances de conteneur vous permet de fournir une configuration dynamique de l'application ou du script exécuté par le conteneur. Le script de déploiement gère les variables d’environnement sécurisées et non sécurisées de la même manière qu’Azure Container Instance. Pour plus d’informations, consultez Définir des variables d’environnement dans des instances de conteneur. Pour un exemple, voir Exemples de modèles.

La taille maximale autorisée pour les variables d’environnement est de 64 Ko.

Analyser et détecter les problèmes des scripts de déploiement

Le service de script crée un compte de stockage (sauf si vous spécifiez un compte de stockage existant) et une instance de conteneur pour l’exécution du script. Si ces ressources sont créées automatiquement par le service de script, les deux ressources ont le suffixe azscripts dans les noms des ressources.

Capture d’écran Noms de la ressource du script de déploiement d’un modèle Resource Manager.

Le script utilisateur, les résultats de l’exécution et le fichier stdout sont stockés dans les partages de fichiers du compte de stockage. Un dossier est nommé azscripts. Dans celui-ci, se trouvent deux dossiers supplémentaires pour les fichiers d’entrée et de sortie : azscriptinput et azscriptoutput.

Le dossier output contient un fichier executionresult.json et le fichier de sortie du script. Vous pouvez voir le message d’erreur de l’exécution du script dans executionresult.json. Le fichier de sortie est créé uniquement lorsque le script est exécuté correctement. Le dossier input contient un fichier de script PowerShell système et les fichiers de script de déploiement utilisateur. Vous pouvez remplacer le fichier de script de déploiement utilisateur par un fichier révisé, puis réexécuter le script de déploiement à partir de l’instance de conteneur Azure.

Utilisation du portail Azure

Une fois que vous avez déployé une ressource de script de déploiement, la ressource est listée sous le groupe de ressources dans la Portail Azure. La capture d’écran suivante montre la page de présentation d’une ressource de script de déploiement :

Capture d’écran de la vue d’ensemble du portail pour un script de déploiement du modèle Resource Manager.

La page de présentation affiche des informations importantes sur la ressource, telles que l’État d’approvisionnement, le Compte de stockage, l’Instance de conteneuret les Journaux.

Dans le menu de gauche, vous pouvez afficher le contenu du script de déploiement, les arguments passés au script et la sortie. Vous pouvez également exporter un modèle pour le script de déploiement, y compris le script de déploiement.

Utiliser PowerShell

À l’aide de Azure PowerShell, vous pouvez gérer les scripts de déploiement au niveau de l’abonnement ou de l’étendue du groupe de ressources :

Le résultat Get-AzDeploymentScript ressemble à ce qui suit :

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

Utiliser l’interface de ligne de commande Microsoft Azure

À l’aide de Azure CLI, vous pouvez gérer les scripts de déploiement au niveau de l’abonnement ou de l’étendue du groupe de ressources :

La sortie de la commande de liste ressemble à ce qui suit :

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

Avec l’API REST

Vous pouvez récupérer les informations de déploiement de la ressource de script de déploiement au niveau du groupe de ressources et du niveau de l’abonnement à l’aide de 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

L’exemple suivant utilise ARMClient :

armclient login
armclient get /subscriptions/01234567-89AB-CDEF-0123-456789ABCDEF/resourcegroups/myrg/providers/microsoft.resources/deploymentScripts/myDeployementScript?api-version=2020-10-01

Le résultat ressemble à ce qui suit :

{
  "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 suivante retourne le journal :

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

Elle fonctionne uniquement avant la suppression des ressources de script de déploiement.

Pour afficher la ressource deploymentScripts dans le portail, sélectionnez Afficher les types masqués :

Capture d’écran d’un script de déploiement du modèle Resource Manager avec l’option Afficher les types masqués dans le portail.

Nettoyer les ressources de script de déploiement

Les deux ressources complémentaires créées automatiquement ne peuvent jamais survivre à la ressource deploymentScript, sauf en cas d’échec de leur suppression. Le cycle de vie des ressources complémentaires est contrôlé par la propriété cleanupPreference. Le cycle de vie de la ressource deploymentScript est contrôlé par la propriété retentionInterval :

  • cleanupPreference : Spécifie la préférence de nettoyage des deux ressources complémentaires quand l’exécution du script arrive à un état terminal. Les valeurs prises en charge sont les suivantes :

    • Always : Supprime les deux ressources complémentaires quand l’exécution du script arrive à un état terminal. Si un compte de stockage existant est utilisé, le service de script supprime le partage de fichiers créé par le service. Étant donné que la ressource deploymentScripts risque d’être toujours présente après le nettoyage des ressources complémentaires, le service de script conserve les résultats de l’exécution du script (par exemple, stdout, sorties et valeur renvoyée) avant la suppression des ressources.

    • OnSuccess : Supprime les deux ressources complémentaires uniquement quand l’exécution du script s’est déroulée correctement. Si un compte de stockage existant est utilisé, le service de script supprime le partage de fichiers uniquement en cas de réussite de l’exécution du script.

      Si l’exécution du script échoue, le service de script attend l’expiration de retentionInterval avant de nettoyer les ressources complémentaires, puis la ressource du script de déploiement.

    • OnExpiration : Supprime les deux ressources complémentaires uniquement quand le paramètre retentionInterval arrive à expiration. Si un compte de stockage existant est utilisé, le service de script supprime le partage de fichiers, mais conserve le compte de stockage.

    L’instance de conteneur et le compte de stockage sont supprimés en fonction de cleanupPreference. Toutefois, si le script échoue et si cleanupPreference n’est pas défini sur Always, le processus de déploiement maintient automatiquement l’exécution du conteneur pendant une heure ou jusqu’au nettoyage du conteneur. Vous pouvez utiliser cette période pour résoudre les problèmes de script. Si vous souhaitez laisser le conteneur s’exécuter après des déploiements réussis, ajoutez une étape de mise en veille à votre script. Par exemple, ajoutez Start-Sleep à la fin de votre script. Si vous n’ajoutez pas l’étape de mise en veille, le conteneur est défini sur un état terminal et n’est pas accessible, même s’il n’a pas encore été supprimé.

  • retentionInterval : Spécifie l’intervalle de temps pendant lequel une ressource deploymentScript est conservée et après lequel elle expire et est supprimée.

Notes

Il n’est pas recommandé d’utiliser le compte de stockage et l’instance de conteneur qui sont générés par le service de script à d’autres fins. Les deux ressources peuvent être supprimées en fonction du cycle de vie du script.

L’instance de compte de stockage et de conteneur créée automatiquement ne peut pas être supprimée si le script de déploiement est déployé vers un groupe de ressources avec un verrou CanNotDelete. Pour résoudre ce problème, vous pouvez déployer le script de déploiement vers un autre groupe de ressources sans verrous. Consultez l’Exemple 4 et l’Exemple 5 dans les Exemples de modèles.

Exécuter le script plusieurs fois

L’exécution d’un script de déploiement est une opération idempotente. Si aucune des propriétés de la ressource deploymentScripts (y compris le script inclus) n’est modifiée, le script ne s’exécute pas lorsque vous redéployez le modèle. Le service de script de déploiement compare les noms des ressource du modèle aux ressources existantes dans le même groupe de ressources. Vous avez deux options à votre disposition si vous souhaitez exécuter le même script de déploiement plusieurs fois :

  • Sélectionnez le nom de votre ressource deploymentScripts. Par exemple, utilisez la fonction de modèle utcNow comme nom de ressource, ou comme partie du nom de la ressource. La modification du nom de la ressource crée une nouvelle ressource deploymentScripts. C’est un moyen pratique pour conserver un historique de l’exécution des scripts.

    Notes

    La fonction utcNow peut uniquement être utilisée dans la valeur par défaut d’un paramètre.

  • Spécifiez une autre valeur dans la propriété de modèle forceUpdateTag. Par exemple, utilisez utcNow comme valeur.

Notes

Écrivez les scripts de déploiement qui sont idempotents. Cela garantit que, s’ils sont exécutés accidentellement, cela n’entraînera de modifications du système. Par exemple, si le script de déploiement est utilisé pour créer une ressource Azure, vérifiez que la ressource n’existe pas avant de la créer, afin que le script aboutisse ou que vous ne recréiez pas la ressource.

Configurer l’environnement de développement

Vous pouvez utiliser une image conteneur préconfigurée comme environnement de développement de scripts de déploiement. Pour plus d’informations, consultez Configuration de l’environnement de développement pour les scripts de déploiement dans les modèles.

Dès lors que le script a été testé avec succès, vous pouvez l’utiliser en tant que script de déploiement dans vos modèles.

Codes d’erreur des scripts de déploiement

Code d'erreur Description
DeploymentScriptInvalidOperation La définition de la ressource de script de déploiement dans le modèle contient des noms de propriétés non valides.
DeploymentScriptResourceConflict Il est impossible de supprimer une ressource de script de déploiement qui se trouve dans un état non terminal et dont l’exécution n’a pas dépassé une heure. Il est également impossible de réexécuter le même script de déploiement avec le même identificateur de ressource (même abonnement, même nom de groupe de ressources et même nom de ressource), mais un contenu de corps de script différent en même temps.
DeploymentScriptOperationFailed L’opération de script de déploiement a échoué en interne. Contactez le Support Microsoft.
DeploymentScriptStorageAccountAccessKeyNotSpecified La clé d’accès n’a pas été spécifiée pour le compte de stockage existant.
DeploymentScriptContainerGroupContainsInvalidContainers Un groupe de conteneurs créé par le service de script de déploiement a été modifié en externe et des conteneurs non valides ont été ajoutés.
DeploymentScriptContainerGroupInNonterminalState Au moins deux ressources de script de déploiement utilisent le même nom Azure Container Instance dans le même groupe de ressources, et l’une d’entre elles n’a pas encore terminé son exécution.
DeploymentScriptStorageAccountInvalidKind Le compte de stockage existant du type BlobBlobStorage ou BlobStorage ne prend pas en charge les partages de fichiers et ne peut pas être utilisé.
DeploymentScriptStorageAccountInvalidKindAndSku Le compte de stockage existant ne prend pas en charge les partages de fichiers. Pour connaître la liste des types de comptes de stockage pris en charge, consultez Recours à un compte de stockage existant.
DeploymentScriptStorageAccountNotFound Le compte de stockage n’existe pas ou a été supprimé par un processus ou un outil externe.
DeploymentScriptStorageAccountWithServiceEndpointEnabled Le compte de stockage spécifié possède un point de terminaison de service. Les comptes de stockage comportant un point de terminaison de service ne sont pas pris en charge.
DeploymentScriptStorageAccountInvalidAccessKey La clé d’accès spécifiée pour le compte de stockage existant n’est pas valide.
DeploymentScriptStorageAccountInvalidAccessKeyFormat Le format de la clé de compte de stockage n’est pas valide. Consultez Gérer les clés d’accès au compte de stockage.
DeploymentScriptExceededMaxAllowedTime Le temps d’exécution du script de déploiement a dépassé la valeur de délai d’attente spécifiée dans la définition de la ressource de script de déploiement.
DeploymentScriptInvalidOutputs La sortie du script de déploiement n’est pas un objet JSON valide.
DeploymentScriptContainerInstancesServiceLoginFailure L’identité managée attribuée par l’utilisateur n’est pas parvenue à se connecter au bout de 10 tentatives à 1 minute d’intervalle.
DeploymentScriptContainerGroupNotFound Un groupe de conteneurs créé par le service de script de déploiement a été supprimé par un processus ou un outil externe.
DeploymentScriptDownloadFailure Le téléchargement d’un script d’accompagnement a échoué. Consultez Utilisation d’un script d’accompagnement.
DeploymentScriptError Le script utilisateur a généré une erreur.
DeploymentScriptBootstrapScriptExecutionFailed Le script de démarrage a généré une erreur. Le script de démarrage correspond au script système qui orchestre l’exécution du script de déploiement.
DeploymentScriptExecutionFailed Une erreur inconnue s’est produite pendant l’exécution du script de déploiement.
DeploymentScriptContainerInstancesServiceUnavailable Lors de la création de l’instance Azure Container Instances (ACI), ACI a généré une erreur Service indisponible.
DeploymentScriptContainerGroupInNonterminalState Lors de la création d’une instance Azure Container Instances (ACI), un autre script de déploiement utilise le même nom ACI dans la même étendue (même abonnement, même nom de groupe de ressources et même nom de ressource).
DeploymentScriptContainerGroupNameInvalid Le nom de l’instance Azure Container Instances (ACI) spécifié ne répond pas aux exigences ACI. Consultez Résolution des problèmes courants dans Azure Container Instances.

Utiliser Microsoft Graph dans un script de déploiement

Un script de déploiement peut utiliser Microsoft Graph pour créer et utiliser des objets dans Microsoft Entra ID.

Commandes

Quand vous utilisez des scripts de déploiement Azure CLI, vous pouvez utiliser des commandes du groupe de commandes az ad pour travailler avec des applications, des principaux de service, des groupes et des utilisateurs. Vous pouvez également appeler directement des API Microsoft Graph à l’aide de la commande az rest.

Quand vous utilisez des scripts de déploiement Azure PowerShell, vous pouvez utiliser la cmdlet Invoke-RestMethod pour appeler directement des API Microsoft Graph.

Autorisations

L’identité utilisée par votre script de déploiement doit être autorisée à utiliser l’API Microsoft Graph et doit avoir les autorisations appropriées pour les opérations qu’il effectue. Vous devez autoriser l’identité en dehors de votre déploiement de modèle, par exemple en créant au préalable une identité managée affectée par l’utilisateur et en lui attribuant un rôle d’application pour Microsoft Graph. Pour plus d’informations, consultez cet exemple de guide de démarrage rapide.

Accéder à un réseau virtuel privé

Avec Microsoft.Resources/deploymentScripts version 2023-08-01, vous pouvez exécuter des scripts de déploiement dans des réseaux privés avec des configurations supplémentaires.

  • Créez une identité managée affectée par l’utilisateur et spécifiez-la dans la propriété identity. Pour affecter l’identité, consultez Identité.

  • Créez un compte de stockage avec allowSharedKeyAccess et défini à true et spécifiez le script de déploiement pour utiliser le compte de stockage existant. Pour spécifier un compte de stockage existant, consultez Utiliser un compte de stockage existant. Une configuration supplémentaire est requise pour le compte de stockage.

    1. Ouvrez le compte de stockage dans le portail Microsoft Azure.

    2. Dans le menu de gauche, sélectionnez Contrôle d’accès (IAM), puis sélectionnez l’onglet Attributions de rôles.

    3. Ajoutez le rôle Storage File Data Privileged Contributor à l’identité managée d’attribution d’utilisateur.

    4. Dans le menu de gauche, sous Sécurité et mise en réseau, sélectionnezMise en réseau, puis sélectionnez Pare-feu et réseaux virtuels.

    5. Sélectionnez Activé à partir de réseaux virtuels et d’adresses IP sélectionnés.

      Capture d’écran de la configuration du compte de stockage pour accéder au réseau privé.

    6. Sous Réseaux virtuels, ajoutez un sous-réseau. Dans la capture d’écran, le sous-réseau est appelé dspvnVnet.

    7. Sous Exceptions, sélectionnez Autoriser les services Azure de la liste des services approuvés à accéder à ce de stockage.

Le modèle ARM suivant montre comment configurer l’environnement pour l’exécution d’un script de déploiement :

{
  "$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'))]"
      ]
    }
  ]
}

Vous pouvez utiliser le modèle ARM suivant pour tester le déploiement :

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

Étapes suivantes

Dans cet article, vous avez appris à utiliser des scripts de déploiement. Pour suivre un tutoriel sur les scripts de déploiement :

Tutoriel : Utiliser des scripts de déploiement dans des modèles Azure Resource Manager

Module d’apprentissage : Étendre des modèles ARM à l’aide de scripts de déploiement