Distribuire un modello di Azure Resource Manager in un runbook PowerShell di Automazione di AzureDeploy an Azure Resource Manager template in an Azure Automation PowerShell runbook

È possibile scrivere un runbook PowerShell di Automazione di Azure che distribuisce una risorsa di Azure usando un modello di Azure Resource Management.You can write an Azure Automation PowerShell runbook that deploys an Azure resource by using an Azure Resource Management template.

Con questa operazione è possibile automatizzare la distribuzione delle risorse di Azure.By doing this, you can automate deployment of Azure resources. È possibile anche gestire i modelli di Resource Manager in una posizione centrale protetta come Archiviazione di Azure.You can maintain your Resource Manager templates in a central,secure location such as Azure Storage.

In questo argomento 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.In this topic, we create a PowerShell runbook that uses an Resource Manager template stored in Azure Storage to deploy a new Azure Storage account.

PrerequisitiPrerequisites

Per completare l'esercitazione, sono necessari gli elementi seguenti:To complete this tutorial, you need the following:

Creare il modello di Azure Resource ManagerCreate the Resource Manager template

In questo esempio si userà un modello di Resource Manager che distribuisce un nuovo account di Archiviazione di Azure.For this example, we use an Resource Manager template that deploys a new Azure Storage account.

In un editor di testo copiare il testo seguente:In a text editor, copy the following text:

{
  "$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"
      }
    }
  },
  "variables": {
    "storageAccountName": "[concat(uniquestring(resourceGroup().id), 'standardsa')]"
  },
  "resources": [
    {
      "type": "Microsoft.Storage/storageAccounts",
      "name": "[variables('storageAccountName')]",
      "apiVersion": "2016-01-01",
      "location": "[resourceGroup().location]",
      "sku": {
          "name": "[parameters('storageAccountType')]"
      },
      "kind": "Storage", 
      "properties": {
      }
    }
  ],
  "outputs": {
      "storageAccountName": {
          "type": "string",
          "value": "[variables('storageAccountName')]"
      }
  }
}

Salvare il file in locale come TemplateTest.json.Save the file locally as TemplateTest.json.

Salvare il modello di Resource Manager in Archiviazione di AzureSave the Resource Manager template in Azure Storage

Si userà ora PowerShell per creare una condivisione file di Archiviazione di Azure e caricare il file TemplateTest.json.Now we use PowerShell to create an Azure Storage file share and upload the TemplateTest.json file. Per istruzioni su come creare una condivisione file e caricare un file nel portale di Azure, vedere Introduzione ad Archiviazione file di Azure in Windows.For instructions on how to create a file share and upload a file in the Azure portal, see Get started with Azure File storage on Windows.

Avviare PowerShell nel computer locale ed eseguire i comandi seguenti per creare una condivisione file e caricare il modello di Resource Manager nella condivisione.Launch PowerShell on your local machine, and run the following commands to create a file share and upload the Resource Manager template to that file share.

# Login to Azure
Login-AzureRmAccount

# Get the access key for your storage account
$key = Get-AzureRmStorageAccountKey -ResourceGroupName 'MyAzureAccount' -Name 'MyStorageAccount'

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

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

# Add the TemplateTest.json file to the new file share
# "TemplatePath" is the path where you saved the TemplateTest.json file
$templateFile = 'C:\TemplatePath'
Set-AzureStorageFileContent -ShareName $fileShare.Name -Context $context -Source $templateFile

Creare lo script del runbook PowerShellCreate the PowerShell runbook script

Si creerà ora uno script di PowerShell che ottiene il file TemplateTest.json da Archiviazione di Azure e distribuisce il modello per creare un nuovo account di Archiviazione di Azure.Now we create a PowerShell script that gets the TemplateTest.json file from Azure Storage and deploys the template to create a new Azure Storage account.

In un editor di testo incollare il testo seguente:In a text editor, paste the following text:

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

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

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

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



# Authenticate to Azure if running from Azure Automation
$ServicePrincipalConnection = Get-AutomationConnection -Name "AzureRunAsConnection"
Add-AzureRmAccount `
    -ServicePrincipal `
    -TenantId $ServicePrincipalConnection.TenantId `
    -ApplicationId $ServicePrincipalConnection.ApplicationId `
    -CertificateThumbprint $ServicePrincipalConnection.CertificateThumbprint | Write-Verbose

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

# Create a new context
$Context = New-AzureStorageContext -StorageAccountKey $StorageAccountKey

Get-AzureStorageFileContent -ShareName 'resource-templates' -Context $Context -path 'TemplateTest.json' -Destination 'C:\Temp'

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

# Deploy the storage account
New-AzureRmResourceGroupDeployment -ResourceGroupName $ResourceGroupName -TemplateFile $TemplateFile -TemplateParameterObject $Parameters 

Salvare il file in locale come DeployTemplate.ps1.Save the file locally as DeployTemplate.ps1.

Importare e pubblicare il runbook nell'account di Automazione di AzureImport and publish the runbook into your Azure Automation account

Si userà ora PowerShell per importare il runbook nell'account di Automazione di Azure e pubblicarlo.Now we use PowerShell to import the runbook into your Azure Automation account, and then publish the runbook. Per informazioni su come importare e pubblicare un runbook nel portale di Azure, vedere Creazione o importazione di un runbook in Automazione di Azure.For information about how to import and publish a runbook in the Azure portal, see Creating or importing a runbook in Azure Automation.

Per importare DeployTemplate.ps1 nell'account di Automazione come un runbook di PowerShell, eseguire i comandi di PowerShell seguenti:To import DeployTemplate.ps1 into your Automation account as a PowerShell runbook, run the following PowerShell commands:

# MyPath is the path where you saved DeployTemplate.ps1
# MyResourceGroup is the name of the Azure ResourceGroup that contains your Azure Automation account
# MyAutomationAccount is the name of your Automation account
$importParams = @{
    Path = 'C:\MyPath\DeployTemplate.ps1'
    ResourceGroupName = 'MyResourceGroup'
    AutomationAccountName = 'MyAutomationAccount'
    Type = 'PowerShell'
}
Import-AzureRmAutomationRunbook @

# Publish the runbook
$publishParams = @{
    ResourceGroupName = 'MyResourceGroup'
    AutomationAccountName = 'MyAutomationAccount'
    Name = 'DeployTemplate'
}
Publish-AzureRmAutomationRunbook @publishParams

Avviare il runbookStart the runbook

Si avvierà ora il runbook chiamando il cmdlet Start-AzureRmAutomationRunbook.Now we start the runbook by calling the Start-AzureRmAutomationRunbook cmdlet.

Per informazioni su come avviare un runbook nel portale di Azure, vedere Avvio di un Runbook in Automazione di Azure.For information about how to start a runbook in the Azure portal, see Starting a runbook in Azure Automation.

Eseguire i comandi seguenti nella console di PowerShell:Run the following commands in the PowerShell console:

# Set up the parameters for the runbook
$runbookParams = @{
    ResourceGroupName = 'MyResourceGroup'
    StorageAccountName = 'MyStorageAccount'
    StorageAccountKey = $key[0].Value # We got this key earlier
    StorageFileName = 'TemplateTest.json' 
}

# Set up parameters for the Start-AzureRmAutomationRunbook cmdlet
$startParams = @{
    ResourceGroupName = 'MyResourceGroup'
    AutomationAccountName = 'MyAutomationAccount'
    Name = 'DeployTemplate'
    Parameters = $runbookParams
}

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

Il runbook viene eseguito ed è possibile verificarne lo stato eseguendo $job.Status.The runbook runs, and you can check its status by running $job.Status.

Il runbook ottiene il modello di Resource Manager e lo usa per distribuire un nuovo account di Archiviazione di Azure.The runbook gets the Resource Manager template and uses it to deploy a new Azure Storage account. È possibile verificare che il nuovo account di archiviazione sia stato creato eseguendo il comando seguente:You can see that the new storage account was created by running the following command:

Get-AzureRmStorageAccount

RiepilogoSummary

L'operazione è terminata.That's it! Sarà ora possibile usare Automazione di Azure, Archiviazione di Azure e modelli di Resource Manager per distribuire tutte le risorse di Azure.Now you can use Azure Automation and Azure Storage, and Resource Manager templates to deploy all your Azure resources.

Passaggi successiviNext steps