Condividi tramite

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

È 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 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 viene creato un runbook di 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 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 Connect-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 Resource Manager

In questo esempio si usa un modello di Resource Manager che distribuisce un nuovo account di 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 nel 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 di 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 di 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 nel proprio account di Automazione di Azure

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

Per importare runbookScript.ps1 nel tuo account di Automazione come runbook di PowerShell, esegui i seguenti comandi di PowerShell:

$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

A questo punto si avvia 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 le esecuzioni del runbook, è possibile controllarne lo stato recuperando il valore della proprietà dell'oggetto processo $job.Status.

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

  • Last updated on