Déployer un modèle Azure Resource Manager dans un runbook Automation PowerShell

  • Article

Vous pouvez écrire un runbook Automation PowerShell qui déploie une ressource Azure en utilisant un modèle Azure Resource Manager. Les modèles vous permettent d’utiliser Azure Automation pour automatiser le déploiement de vos ressources Azure. Vous pouvez gérer vos modèles Resource Manager dans un emplacement central et sécurisé tel que le Stockage Azure.

Dans cet article, nous créons un runbook PowerShell qui utilise un modèle Resource Manager stocké dans le service Stockage Azure pour déployer un nouveau compte de stockage Azure.

Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.

Prérequis

Attribuer des autorisations aux identités managées

Attribuez des autorisations aux identités managées pour effectuer les tâches liées au stockage dans le runbook.

  1. Connectez-vous à Azure de manière interactive à l’aide de la cmdlet Connect-AzAccount et suivez les instructions.

    # Sign in to your Azure subscription
$sub = Get-AzSubscription -ErrorAction SilentlyContinue
if(-not($sub))
{
    Connect-AzAccount
}

# If you have multiple subscriptions, set the one to use
# Select-AzSubscription -SubscriptionId <SUBSCRIPTIONID>

  2. Fournissez une valeur appropriée pour les variables ci-dessous, puis exécutez le script.

    $resourceGroup = "resourceGroup"
$automationAccount = "automationAccount"
$storageAccount = "storageAccount"
$userAssignedManagedIdentity = "userAssignedManagedIdentity"
$storageTemplate = "path\storageTemplate.json"
$runbookScript = "path\runbookScript.ps1"

  3. Attribuez le rôle reader à l’identité managée affectée par le système pour exécuter la cmdlet Get-AzUserAssignedIdentity.

    $SAMI = (Get-AzAutomationAccount -ResourceGroupName $resourceGroup -Name $automationAccount).Identity.PrincipalId
New-AzRoleAssignment `
    -ObjectId $SAMI `
    -ResourceGroupName $resourceGroup `
    -RoleDefinitionName "Reader"

  4. Attribuez le rôle Storage Account Contributor à l’identité managée affectée par l’utilisateur pour les actions sur le compte de stockage.

    $UAMI_ID = (Get-AzUserAssignedIdentity -ResourceGroupName $resourceGroup -Name $userAssignedManagedIdentity).PrincipalId
New-AzRoleAssignment `
    -ObjectId $UAMI_ID `
    -ResourceGroupName $resourceGroup `
    -RoleDefinitionName "Storage Account Contributor"

Créer le modèle Resource Manager

Dans cet exemple, vous utilisez un modèle Resource Manager qui déploie un nouveau compte de stockage Azure. Créez un fichier local appelé storageTemplate.json et collez-y le code suivant :

{
  "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "storageAccountType": {
      "type": "string",
      "defaultValue": "Standard_LRS",
      "allowedValues": [
        "Standard_LRS",
        "Standard_GRS",
        "Standard_ZRS",
        "Premium_LRS"
      ],
      "metadata": {
        "description": "Storage Account type"
      }
    },
    "location": {
      "type": "string",
      "defaultValue": "[resourceGroup().location]",
      "metadata": {
        "description": "Location for all resources."
      }
    }
  },
  "variables": {
    "storageAccountName": "[concat(uniquestring(resourceGroup().id), 'standardsa')]"
  },
  "resources": [
    {
      "type": "Microsoft.Storage/storageAccounts",
      "name": "[variables('storageAccountName')]",
      "apiVersion": "2018-02-01",
      "location": "[parameters('location')]",
      "sku": {
          "name": "[parameters('storageAccountType')]"
      },
      "kind": "Storage", 
      "properties": {
      }
    }
  ],
  "outputs": {
      "storageAccountName": {
          "type": "string",
          "value": "[variables('storageAccountName')]"
      }
  }
}

Enregistrer le modèle Resource Manager dans Stockage Azure

Utilisez PowerShell pour créer un partage de fichiers Azure et chargez-y storageTemplate.json. Pour obtenir des instructions sur la création d’un partage de fichier et sur le chargement d’un fichier sur le portail Azure, consultez Bien démarrer avec le stockage de fichiers Azure sur Windows.

Exécutez les commandes suivantes pour créer un partage de fichiers et y charger le modèle Resource Manager.

# Get the access key for your storage account
$key = Get-AzStorageAccountKey -ResourceGroupName $resourceGroup -Name $storageAccount

# Create an Azure Storage context using the first access key
$context = New-AzStorageContext -StorageAccountName $storageAccount -StorageAccountKey $key[0].value

# Create a file share named 'resource-templates' in your Azure Storage account
$fileShare = New-AzStorageShare -Name 'resource-templates' -Context $context

# Add the storageTemplate.json file to the new file share
Set-AzStorageFileContent -ShareName $fileShare.Name -Context $context -Source $storageTemplate

Créer le script de runbook PowerShell

Créez un script PowerShell qui récupère le fichier storageTemplate.json auprès de Stockage Azure et déploie le modèle pour créer un nouveau compte de stockage Azure. Créez un fichier local appelé runbookScript.ps1 et collez-y le code suivant :

param (
    [Parameter(Mandatory=$true)]
    [string]
    $resourceGroup,

    [Parameter(Mandatory=$true)]
    [string]
    $storageAccount,

    [Parameter(Mandatory=$true)]
    [string]
    $storageAccountKey,

    [Parameter(Mandatory=$true)]
    [string]
    $storageFileName,

    [Parameter(Mandatory=$true)]
    [string]
    $userAssignedManagedIdentity
)

# Ensures you do not inherit an AzContext in your runbook
Disable-AzContextAutosave -Scope Process

# Connect to Azure with user-assigned managed identity
$AzureContext = (Connect-AzAccount -Identity).context
$identity = Get-AzUserAssignedIdentity -ResourceGroupName $resourceGroup `
    -Name $userAssignedManagedIdentity `
    -DefaultProfile $AzureContext
$AzureContext = (Connect-AzAccount -Identity -AccountId $identity.ClientId).context

# set and store context
$AzureContext = Set-AzContext -SubscriptionName $AzureContext.Subscription `
    -DefaultProfile $AzureContext

#Set the parameter values for the Resource Manager template
$Parameters = @{
    "storageAccountType"="Standard_LRS"
    }

# Create a new context
$Context = New-AzStorageContext -StorageAccountName $storageAccount -StorageAccountKey $storageAccountKey

Get-AzStorageFileContent `
    -ShareName 'resource-templates' `
    -Context $Context `
    -path 'storageTemplate.json' `
    -Destination 'C:\Temp' -Force

$TemplateFile = Join-Path -Path 'C:\Temp' -ChildPath $storageFileName

# Deploy the storage account
New-AzResourceGroupDeployment `
    -ResourceGroupName $resourceGroup `
    -TemplateFile $TemplateFile `
    -TemplateParameterObject $Parameters

Importer et publier le runbook dans votre compte Azure Automation

Utilisez PowerShell pour importer le runbook dans votre compte Automation, puis publiez le runbook. Pour plus d’informations sur l’importation et la publication de runbooks sur le portail Azure, consultez Gérer des runbooks dans Azure Automation.

Pour importer runbookScript.ps1 dans votre compte Automation en tant que runbook PowerShell, exécutez les commandes PowerShell suivantes :

$importParams = @{
    Path = $runbookScript
    ResourceGroupName = $resourceGroup
    AutomationAccountName = $automationAccount
    Type = "PowerShell"
}
Import-AzAutomationRunbook @importParams

# Publish the runbook
$publishParams = @{
    ResourceGroupName = $resourceGroup
    AutomationAccountName = $automationAccount
    Name = "runbookScript"
}
Publish-AzAutomationRunbook @publishParams

Démarrer le runbook

Nous allons maintenant démarrer le runbook en appelant la cmdlet Start-AzAutomationRunbook. Pour plus d’informations sur la façon de démarrer un runbook dans le portail Azure, consultez Démarrage d’un Runbook dans Azure Automation.

Dans la console PowerShell, exécutez les commandes suivantes :

# Set up the parameters for the runbook
$runbookParams = @{
    resourceGroup = $resourceGroup
    storageAccount = $storageAccount
    storageAccountKey = $key[0].Value # We got this key earlier
    storageFileName = "storageTemplate.json"
    userAssignedManagedIdentity = $userAssignedManagedIdentity
}

# Set up parameters for the Start-AzAutomationRunbook cmdlet
$startParams = @{
    resourceGroup = $resourceGroup
    AutomationAccountName = $automationAccount
    Name = "runbookScript"
    Parameters = $runbookParams
}

# Start the runbook
$job = Start-AzAutomationRunbook @startParams

Une fois que le runbook s’exécute, vous pouvez vérifier son état en extrayant la valeur de propriété de l’objet de traitement $job.Status.

Le runbook récupère le modèle Resource Manager et l’utilise pour déployer un nouveau compte de stockage Azure. Vous pouvez voir que le nouveau compte de stockage a été créé en exécutant la commande suivante :

Get-AzStorageAccount

Étapes suivantes