Een Azure Resource Manager implementeren in een Automation PowerShell-runbook

  • Artikel
  • 5 minuten om te lezen

U kunt een Automation PowerShell-runbook schrijven dat een Azure-resource implementeert met behulp van een Azure Resource Manager sjabloon. Met sjablonen kunt u Azure Automation om de implementatie van uw Azure-resources te automatiseren. U kunt uw Resource Manager sjablonen onderhouden op een centrale, veilige locatie, zoals Azure Storage.

In dit artikel maken we een PowerShell-runbook dat gebruikmaakt van een Resource Manager-sjabloon die is opgeslagen in Azure Storage om een nieuw Azure Storage implementeren.

Als u nog geen abonnement op Azure hebt, maak dan een gratis account aan voordat u begint.

Vereisten

  • Een Azure Automation account met ten minste één door de gebruiker toegewezen beheerde identiteit. Zie Using a user-assigned managed identity for an Azure Automation account (Een doorde gebruiker toegewezen beheerde identiteit gebruiken voor een Azure Automation-account) voor meer informatie.

  • Az-modules: Az.Accounts Az.ManagedServiceIdentity , , en Az.Resources Az.Storage . geïmporteerd in het Automation-account. Zie Az-modules importeren voor meer informatie.

  • Azure Storage account waarin de sjabloon moet worden Resource Manager opgeslagen.

  • Azure PowerShell geïnstalleerd op een lokale computer. Zie Install the Azure PowerShell Module (De Azure PowerShell-module installeren) voor meer informatie over het verkrijgen van Azure PowerShell. U hebt ook module Az.ManagedServiceIdentity nodig. Az.ManagedServiceIdentity is een preview-module en is niet geïnstalleerd als onderdeel van de Az-module. Voer uit om het te installeren Install-Module -Name Az.ManagedServiceIdentity

Machtigingen toewijzen aan beheerde identiteiten

Wijs machtigingen toe aan de beheerde identiteiten om de opslaggerelateerde taken in het runbook uit te voeren.

  1. Meld u interactief aan bij Azure met de cmdlet Verbinding maken-AzAccount en volg de instructies.

    # 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. Geef een geschikte waarde op voor de onderstaande variabelen en voer vervolgens het script uit.

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

  3. Wijs de rol reader toe aan de door het systeem toegewezen beheerde identiteit om de cmdlet uit te Get-AzUserAssignedIdentity voeren.

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

  4. Wijs de rol Storage Account Contributor toe aan de door de gebruiker toegewezen beheerde identiteit voor acties voor het opslagaccount.

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

Het Resource Manager-sjabloon maken

In dit voorbeeld gebruikt u een Resource Manager die een nieuw Azure Storage implementeert. Maak een lokaal bestand met de storageTemplate.json naam en plak de volgende code:

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

Sla de sjabloon Resource Manager op in Azure Files

Gebruik PowerShell om een Azure-bestands share te maken en te storageTemplate.json uploaden. Zie Aan de slag met Azure Files op Windows voor instructies over het maken van een bestands share en het uploaden van een bestand in Azure Portal.

Voer de volgende opdrachten uit om een bestands share te maken en de sjabloon Resource Manager uploaden naar die bestands share.

# 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

Het PowerShell-runbookscript maken

Maak een PowerShell-script dat het bestand uit Azure Storage en implementeert de sjabloon om een nieuw Azure Storage storageTemplate.json maken. Maak een lokaal bestand met de runbookScript.ps1 naam en plak de volgende code:

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

Het runbook importeren en publiceren in uw Azure Automation account

Gebruik PowerShell om het runbook te importeren in uw Automation-account en publiceer vervolgens het runbook. Zie Runbooks beheren in Azure Automation voor meer informatie over het importeren en publiceren van runbooks in Azure Portal.

Voer de runbookScript.ps1 volgende PowerShell-opdrachten uit om als Een PowerShell-runbook in uw Automation-account te importeren:

$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

Het runbook starten

Nu starten we het runbook door de cmdlet Start-AzAutomationRunbook aan te roepen. Zie Starting a runbook in Azure Portal (Een runbook starten in Azure Automation) voor meer informatie over het starten van een runbook in Azure Automation.

Voer de volgende opdrachten uit in de PowerShell-console:

# 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

Nadat het runbook is uitgevoerd, kunt u de status ervan controleren door de eigenschapswaarde van het taakobject op te $job.Status haalt.

Het runbook haalt de sjabloon Resource Manager en gebruikt deze om een nieuw Azure Storage implementeren. U kunt zien dat het nieuwe opslagaccount is gemaakt door de volgende opdracht uit te voeren:

Get-AzStorageAccount

Volgende stappen