Distribuire un modello di Azure Resource Manager in un runbook di PowerShell di Automazione

  • Articolo

È possibile scrivere un runbook di PowerShell di Automazione che distribuisce una risorsa di Azure usando un modello di Azure Resource Manager. I modelli consentono di usare Automazione di Azure zure per automatizzare la distribuzione delle risorse di Azure. È possibile anche gestire i modelli di Resource Manager in una posizione centrale protetta come Archiviazione di Azure.

In questo articolo si creerà un runbook PowerShell che usa un modello di Resource Manager archiviato in Archiviazione di Azure per distribuire un nuovo account di Archiviazione di Azure.

Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.

Prerequisiti

Assegnare le autorizzazioni alle identità gestite

Assegnare le autorizzazioni alle identità gestite per eseguire le attività correlate all'archiviazione nel Runbook.

  1. Accedere ad Azure in modo interattivo usando il cmdlet Connessione-AzAccount e seguire le istruzioni.

    # 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. Specificare un valore appropriato per le variabili seguenti e quindi eseguire lo script.

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

  3. Assegnare il ruolo reader all'identità gestita assegnata dal sistema per eseguire il cmdlet Get-AzUserAssignedIdentity.

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

  4. Assegnare il ruolo Storage Account Contributor all'identità gestita assegnata dall'utente per le azioni sull'account di archiviazione.

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

Creare il modello di Azure Resource Manager

In questo esempio si usa un modello di Resource Manager che distribuisce un nuovo account Archiviazione di Azure. Creare un file locale denominato storageTemplate.json e quindi incollare il codice seguente:

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

Salvare il modello di Resource Manager in File di Azure

Usare PowerShell per creare una condivisione file di Azure e caricare storageTemplate.json. Per istruzioni su come creare una condivisione file e caricare un file nella portale di Azure, vedere Introduzione a File di Azure in Windows.

Eseguire i comandi seguenti per creare una condivisione file e caricare il modello di Resource Manager in tale condivisione file.

# 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

Creare lo script del runbook PowerShell

Creare uno script di PowerShell che ottiene il storageTemplate.json file da Archiviazione di Azure e distribuisce il modello per creare un nuovo account Archiviazione di Azure. Creare un file locale denominato runbookScript.ps1 e quindi incollare il codice seguente:

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

Importare e pubblicare il runbook nell'account di Automazione di Azure

Usare PowerShell per importare il runbook nell'account di Automazione e quindi pubblicare il runbook. Per informazioni sull'importazione e la pubblicazione di runbook nella portale di Azure, vedere Gestire i runbook in Automazione di Azure.

Per importare runbookScript.ps1 nell'account di Automazione come un runbook di PowerShell, eseguire i comandi di PowerShell seguenti:

$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

Avviare il runbook

Si avvierà ora il runbook chiamando il cmdlet Start-AzAutomationRunbook. Per informazioni su come avviare un runbook nel portale di Azure, vedere Avvio di un Runbook in Automazione di Azure.

Eseguire i comandi seguenti nella console di PowerShell:

# 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

Dopo l'esecuzione del runbook, è possibile controllarne lo stato recuperando il valore della proprietà dell'oggetto $job.Statusprocesso .

Il runbook ottiene il modello di Resource Manager e lo usa per distribuire un nuovo account di Archiviazione di Azure. È possibile vedere che il nuovo account di archiviazione è stato creato eseguendo il comando seguente:

Get-AzStorageAccount

Passaggi successivi