Met behulp van gekoppelde en geneste sjablonen bij het implementeren van Azure-resourcesUsing linked and nested templates when deploying Azure resources

Voor het implementeren van uw oplossing, kunt u één enkele sjabloon of een belangrijkste sjabloon kunt gebruiken met veel gerelateerde sjablonen.To deploy your solution, you can use either a single template or a main template with many related templates. De gerelateerde sjablonen kunnen afzonderlijke bestanden zijn die zijn gekoppeld aan uit de hoofd sjabloon of sjablonen die zijn genest in de hoofd sjabloon.The related templates can either be separate files that are linked to from the main template, or templates that are nested within the main template.

Voor kleine tot middelgrote oplossingen is één enkele sjabloon gemakkelijker te begrijpen en onderhouden.For small to medium solutions, a single template is easier to understand and maintain. U kunt alle resources en -waarden in een enkel bestand zien.You can see all the resources and values in a single file. Voor geavanceerde scenario's kunt u met gekoppelde sjablonen de oplossing opsplitsen in doel onderdelen.For advanced scenarios, linked templates enable you to break down the solution into targeted components. U kunt deze sjablonen eenvoudig opnieuw gebruiken voor andere scenario's.You can easily reuse these templates for other scenarios.

Wanneer u gekoppelde sjablonen gebruikt, maakt u een belangrijkste sjabloon waarmee de parameterwaarden die zijn ontvangen tijdens de implementatie.When using linked templates, you create a main template that receives the parameter values during deployment. De belangrijkste sjabloon bevat alle gekoppelde sjablonen en geeft waarden aan deze sjablonen indien nodig.The main template contains all the linked templates and passes values to those templates as needed.

Zie voor een zelfstudie zelfstudie: gekoppelde Azure Resource Manager-sjablonen maken.For a tutorial, see Tutorial: create linked Azure Resource Manager templates.

Notitie

Voor gekoppelde of geneste sjablonen kunt u alleen incrementele implementatie modus gebruiken.For linked or nested templates, you can only use Incremental deployment mode.

Implementaties bronDeployments resource

Als u wilt koppelen aan een andere sjabloon, Voeg een implementaties resource die u wilt uw belangrijkste sjabloon.To link to another template, add a deployments resource to your main template.

"resources": [
  {
    "type": "Microsoft.Resources/deployments",
    "apiVersion": "2018-05-01",
    "name": "linkedTemplate",
    "properties": {
        "mode": "Incremental",
        <nested-template-or-external-template>
    }
  }
]

De eigenschappen die u voor de implementatie-resource opgeeft, afhankelijk van of u bent koppelen aan een externe-sjabloon of een inline-sjabloon in de belangrijkste sjabloon nesten.The properties you provide for the deployment resource vary based on whether you're linking to an external template or nesting an inline template in the main template.

Geneste sjabloonNested template

Als u wilt de sjabloon in de belangrijkste sjabloon nesten, gebruikt u de sjabloon eigenschap en geeft u de sjabloonsyntaxis van de.To nest the template within the main template, use the template property and specify the template syntax.

"resources": [
  {
    "type": "Microsoft.Resources/deployments",
    "apiVersion": "2018-05-01",
    "name": "nestedTemplate",
    "properties": {
      "mode": "Incremental",
      "template": {
        "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
        "contentVersion": "1.0.0.0",
        "resources": [
          {
            "type": "Microsoft.Storage/storageAccounts",
            "apiVersion": "2019-04-01",
            "name": "[variables('storageName')]",
            "location": "West US",
            "kind": "StorageV2",
            "sku": {
                "name": "Standard_LRS"
            }
          }
        ]
      }
    }
  }
]

Notitie

Voor geneste sjablonen, kunt u parameters en variabelen die zijn gedefinieerd in de geneste sjabloon niet gebruiken.For nested templates, you cannot use parameters or variables that are defined within the nested template. U kunt parameters en variabelen van de belangrijkste sjabloon gebruiken.You can use parameters and variables from the main template. In het voorgaande voorbeeld [variables('storageName')] haalt een waarde op basis van de belangrijkste sjabloon, niet de geneste sjabloon.In the preceding example, [variables('storageName')] retrieves a value from the main template, not the nested template. Deze beperking geldt niet voor externe sjablonen.This restriction does not apply to external templates.

Voor twee resources die zijn gedefinieerd binnen een geneste sjabloon en waarvan één resource afhankelijk is, is de waarde van de afhankelijkheid gewoon de naam van de afhankelijke resource:For two resources defined inside a nested template and one resource depends on the other, the value of the dependency is simply the name of the dependent resource:

"dependsOn": [
  "[variables('storageAccountName')]"
],

U kunt de functie reference niet gebruiken in het gedeelte outputs van een geneste sjabloon voor een resource die u in de geneste sjabloon hebt geïmplementeerd.You can't use the reference function in the outputs section of a nested template for a resource you have deployed in the nested template. Als u wilt de waarden voor een geïmplementeerde resource in een geneste sjabloon, uw geneste sjabloon te converteren naar een gekoppelde sjabloon.To return the values for a deployed resource in a nested template, convert your nested template to a linked template.

De geneste sjabloon moet de dezelfde eigenschappen als een standaardsjabloon.The nested template requires the same properties as a standard template.

Externe sjabloonExternal template

Als u een koppeling wilt maken naar een externe sjabloon, gebruikt u de eigenschap templateLink .To link to an external template, use the templateLink property. U kunt een lokaal bestand of een bestand dat is alleen beschikbaar op uw lokale netwerk opgeven.You can't specify a local file or a file that is only available on your local network. U kunt alleen opgeven met een URI-waarde met een http of https.You can only provide a URI value that includes either http or https. Resource Manager moet toegang hebben tot de sjabloon.Resource Manager must be able to access the template.

Een optie is de gekoppelde sjabloon in een storage-account en gebruik van de URI voor dit item.One option is to place your linked template in a storage account, and use the URI for that item.

U kunt de para meters voor uw externe sjabloon opgeven in een extern bestand of in inline.You can provide the parameters for your external template either in an external file or inline.

Externe para metersExternal parameters

Wanneer u een extern parameter bestand opgeeft, gebruikt u de eigenschap parametersLink :When providing an external parameter file, use the parametersLink property:

"resources": [
  {
    "type": "Microsoft.Resources/deployments",
    "apiVersion": "2018-05-01",
    "name": "linkedTemplate",
    "properties": {
      "mode": "Incremental",
      "templateLink": {
        "uri":"https://mystorageaccount.blob.core.windows.net/AzureTemplates/newStorageAccount.json",
        "contentVersion":"1.0.0.0"
      },
      "parametersLink": {
        "uri":"https://mystorageaccount.blob.core.windows.net/AzureTemplates/newStorageAccount.parameters.json",
        "contentVersion":"1.0.0.0"
      }
    }
  }
]

U hoeft te bieden de contentVersion eigenschap voor de sjabloon of de parameters.You don't have to provide the contentVersion property for the template or parameters. Als u een waarde voor de inhoud versie niet opgeeft, wordt de huidige versie van de sjabloon wordt geïmplementeerd.If you don't provide a content version value, the current version of the template is deployed. Als u een waarde voor de inhoudsversie opgeeft, moet deze overeenkomen met de versie in de gekoppelde sjabloon. anders mislukt de implementatie met een fout.If you provide a value for content version, it must match the version in the linked template; otherwise, the deployment fails with an error.

Inline-para metersInline parameters

Of u kunt de parameter-inline opgeeft tussen.Or, you can provide the parameter inline. U kunt zowel inline-parameters en een koppeling niet gebruiken voor een parameterbestand.You can't use both inline parameters and a link to a parameter file. De implementatie is mislukt met foutmelding wanneer beide parametersLink en parameters zijn opgegeven.The deployment fails with an error when both parametersLink and parameters are specified.

Als u een waarde van de hoofd sjabloon wilt door geven aan de gekoppelde sjabloon, gebruikt u de eigenschap para meters .To pass a value from the main template to the linked template, use the parameters property.

"resources": [
  {
     "type": "Microsoft.Resources/deployments",
     "apiVersion": "2018-05-01",
     "name": "linkedTemplate",
     "properties": {
       "mode": "Incremental",
       "templateLink": {
          "uri":"https://mystorageaccount.blob.core.windows.net/AzureTemplates/newStorageAccount.json",
          "contentVersion":"1.0.0.0"
       },
       "parameters": {
          "StorageAccountName":{"value": "[parameters('StorageAccountName')]"}
        }
     }
  }
]

Kopiëren gebruikenUsing copy

Als u meerdere exemplaren van een resource met een geneste sjabloon wilt maken, voegt u het element Copy toe op het niveau van de resource micro soft. resources/Deployments .To create multiple instances of a resource with a nested template, add the copy element at the level of the Microsoft.Resources/deployments resource.

In de volgende voorbeeld sjabloon ziet u hoe u een kopie gebruikt met een geneste sjabloon.The following example template shows how to use copy with a nested template.

"resources": [
  {
    "type": "Microsoft.Resources/deployments",
    "apiVersion": "2018-05-01",
    "name": "[concat('nestedTemplate', copyIndex())]",
    // yes, copy works here
    "copy":{
      "name": "storagecopy",
      "count": 2
    },
    "properties": {
      "mode": "Incremental",
      "template": {
        "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
        "contentVersion": "1.0.0.0",
        "resources": [
          {
            "type": "Microsoft.Storage/storageAccounts",
            "apiVersion": "2019-04-01",
            "name": "[concat(variables('storageName'), copyIndex())]",
            "location": "West US",
            "kind": "StorageV2",
            "sku": {
              "name": "Standard_LRS"
            }
            // no, copy doesn't work here
            //"copy":{
            //  "name": "storagecopy",
            //  "count": 2
            //}
          }
        ]
      }
    }
  }
]

De voorgaande voorbeelden toonden vastgelegde URL waarden voor de sjabloon-koppelingen.The previous examples showed hard-coded URL values for the template links. Deze benadering werkt mogelijk voor een eenvoudige sjabloon, maar werkt niet goed als u werkt met een groot aantal modulaire sjablonen.This approach might work for a simple template but it doesn't work well when working with a large set of modular templates. U kunt in plaats daarvan een statische variabele waarin een basis-URL voor de belangrijkste sjabloon maken en vervolgens de URL's voor de gekoppelde sjablonen vanuit die basis-URL dynamisch maken.Instead, you can create a static variable that stores a base URL for the main template and then dynamically create URLs for the linked templates from that base URL. Het voordeel van deze benadering is kunt u eenvoudig verplaatsen of de sjabloon splitsen omdat u alleen hoeft te wijzigen van de statische variabele in de belangrijkste sjabloon.The benefit of this approach is you can easily move or fork the template because you only need to change the static variable in the main template. De belangrijkste sjabloon wordt de juiste URI's in de sjabloon opgesplitste doorgegeven.The main template passes the correct URIs throughout the decomposed template.

Het volgende voorbeeld laat zien hoe u een basis-URL om te maken van twee URL's voor de gekoppelde sjablonen (sharedTemplateUrl en vmTemplate).The following example shows how to use a base URL to create two URLs for linked templates (sharedTemplateUrl and vmTemplate).

"variables": {
    "templateBaseUrl": "https://raw.githubusercontent.com/Azure/azure-quickstart-templates/master/postgresql-on-ubuntu/",
    "sharedTemplateUrl": "[concat(variables('templateBaseUrl'), 'shared-resources.json')]",
    "vmTemplateUrl": "[concat(variables('templateBaseUrl'), 'database-2disk-resources.json')]"
}

U kunt ook deployment() aan de basis-URL ophalen voor de huidige sjabloon, en gebruik die om de URL voor andere sjablonen op dezelfde locatie.You can also use deployment() to get the base URL for the current template, and use that to get the URL for other templates in the same location. Deze methode is handig als uw sjabloon locatie verandert of als u wilt voorkomen dat URL's in het sjabloonbestand hard coderen.This approach is useful if your template location changes or you want to avoid hard coding URLs in the template file. De eigenschap templateLink wordt alleen geretourneerd wanneer u een koppeling naar een externe sjabloon met een URL.The templateLink property is only returned when linking to a remote template with a URL. Als u een lokale sjabloon, is deze eigenschap niet beschikbaar.If you're using a local template, that property isn't available.

"variables": {
    "sharedTemplateUrl": "[uri(deployment().properties.templateLink.uri, 'shared-resources.json')]"
}

Waarden ophalen uit de gekoppelde sjabloonGet values from linked template

Als u een uitvoerwaarde op basis van een gekoppelde sjabloon, halen de waarde van de eigenschap met de syntaxis, zoals: "[reference('deploymentName').outputs.propertyName.value]".To get an output value from a linked template, retrieve the property value with syntax like: "[reference('deploymentName').outputs.propertyName.value]".

Bij het ophalen van een eigenschap van een uitvoer van een gekoppelde sjabloon, kan niet de eigenschapsnaam van de een streepje bestaan.When getting an output property from a linked template, the property name can't include a dash.

De volgende voorbeelden laten zien hoe u verwijzen naar een gekoppelde sjabloon en een uitvoerwaarde op te halen.The following examples demonstrate how to reference a linked template and retrieve an output value. De gekoppelde sjabloon retourneert een eenvoudige bericht.The linked template returns a simple message.

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {},
    "variables": {},
    "resources": [],
    "outputs": {
        "greetingMessage": {
            "value": "Hello World",
            "type" : "string"
        }
    }
}

De belangrijkste sjabloon implementeert de gekoppelde sjabloon en de geretourneerde waarde opgehaald.The main template deploys the linked template and gets the returned value. U ziet dat deze verwijst naar de implementatie-resource met de naam, en maakt gebruik van de naam van de eigenschap die wordt geretourneerd door de gekoppelde sjabloon.Notice that it references the deployment resource by name, and it uses the name of the property returned by the linked template.

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {},
    "variables": {},
    "resources": [
        {
            "type": "Microsoft.Resources/deployments",
            "apiVersion": "2018-05-01",
            "name": "linkedTemplate",
            "properties": {
                "mode": "Incremental",
                "templateLink": {
                    "uri": "[uri(deployment().properties.templateLink.uri, 'helloworld.json')]",
                    "contentVersion": "1.0.0.0"
                }
            }
        }
    ],
    "outputs": {
        "messageFromLinkedTemplate": {
            "type": "string",
            "value": "[reference('linkedTemplate').outputs.greetingMessage.value]"
        }
    }
}

Net als andere resourcetypen, kunt u de afhankelijkheden tussen de gekoppelde sjabloon en andere resources instellen.Like other resource types, you can set dependencies between the linked template and other resources. Als voor andere resources een uitvoer waarde van de gekoppelde sjabloon is vereist, moet u ervoor zorgen dat de gekoppelde sjabloon wordt geïmplementeerd.When other resources require an output value from the linked template, make sure the linked template is deployed before them. Of, als de gekoppelde sjabloon, is afhankelijk van andere bronnen, zorg ervoor dat andere resources worden geïmplementeerd voordat u de gekoppelde sjabloon.Or, when the linked template relies on other resources, make sure other resources are deployed before the linked template.

Het volgende voorbeeld ziet u een sjabloon die wordt geïmplementeerd een openbaar IP-adres en retourneert de resource-ID:The following example shows a template that deploys a public IP address and returns the resource ID:

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "publicIPAddresses_name": {
            "type": "string"
        }
    },
    "variables": {},
    "resources": [
        {
            "type": "Microsoft.Network/publicIPAddresses",
            "apiVersion": "2018-11-01",
            "name": "[parameters('publicIPAddresses_name')]",
            "location": "eastus",
            "properties": {
                "publicIPAddressVersion": "IPv4",
                "publicIPAllocationMethod": "Dynamic",
                "idleTimeoutInMinutes": 4
            },
            "dependsOn": []
        }
    ],
    "outputs": {
        "resourceID": {
            "type": "string",
            "value": "[resourceId('Microsoft.Network/publicIPAddresses', parameters('publicIPAddresses_name'))]"
        }
    }
}

Koppeling naar de sjabloon voor het gebruik van het openbare IP-adres van de voorgaande sjabloon bij het implementeren van een load balancer, en een afhankelijkheid op de implementatie-resource toevoegen.To use the public IP address from the preceding template when deploying a load balancer, link to the template and add a dependency on the deployment resource. Het openbare IP-adres op de load balancer is ingesteld op de uitvoerwaarde van de gekoppelde sjabloon.The public IP address on the load balancer is set to the output value from the linked template.

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "loadBalancers_name": {
            "defaultValue": "mylb",
            "type": "string"
        },
        "publicIPAddresses_name": {
            "defaultValue": "myip",
            "type": "string"
        }
    },
    "variables": {},
    "resources": [
        {
            "type": "Microsoft.Network/loadBalancers",
            "apiVersion": "2018-11-01",
            "name": "[parameters('loadBalancers_name')]",
            "location": "eastus",
            "properties": {
                "frontendIPConfigurations": [
                    {
                        "name": "LoadBalancerFrontEnd",
                        "properties": {
                            "privateIPAllocationMethod": "Dynamic",
                            "publicIPAddress": {
                                "id": "[reference('linkedTemplate').outputs.resourceID.value]"
                            }
                        }
                    }
                ],
                "backendAddressPools": [],
                "loadBalancingRules": [],
                "probes": [],
                "inboundNatRules": [],
                "outboundNatRules": [],
                "inboundNatPools": []
            },
            "dependsOn": [
                "linkedTemplate"
            ]
        },
        {
            "type": "Microsoft.Resources/deployments",
            "apiVersion": "2018-05-01",
            "name": "linkedTemplate",
            "properties": {
                "mode": "Incremental",
                "templateLink": {
                    "uri": "[uri(deployment().properties.templateLink.uri, 'publicip.json')]",
                    "contentVersion": "1.0.0.0"
                },
                "parameters":{
                    "publicIPAddresses_name":{"value": "[parameters('publicIPAddresses_name')]"}
                }
            }
        }
    ]
}

Gekoppelde en geneste sjablonen in de implementatiegeschiedenisLinked and nested templates in deployment history

Elke sjabloon verwerkt Resource Manager als een afzonderlijke implementatie in de geschiedenis van de implementatie.Resource Manager processes each template as a separate deployment in the deployment history. Daarom een belangrijke sjabloon met drie gekoppelde of geneste sjablonen wordt weergegeven in de geschiedenis van de implementatie als:Therefore, a main template with three linked or nested templates appears in the deployment history as:

Implementatiegeschiedenis

U kunt deze afzonderlijke items in de geschiedenis voor het ophalen van uitvoerwaarden na de implementatie.You can use these separate entries in the history to retrieve output values after the deployment. De volgende sjabloon wordt een openbaar IP-adres en het IP-adres weergeeft:The following template creates a public IP address and outputs the IP address:

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "publicIPAddresses_name": {
            "type": "string"
        }
    },
    "variables": {},
    "resources": [
        {
            "type": "Microsoft.Network/publicIPAddresses",
            "apiVersion": "2018-11-01",
            "name": "[parameters('publicIPAddresses_name')]",
            "location": "southcentralus",
            "properties": {
                "publicIPAddressVersion": "IPv4",
                "publicIPAllocationMethod": "Static",
                "idleTimeoutInMinutes": 4,
                "dnsSettings": {
                    "domainNameLabel": "[concat(parameters('publicIPAddresses_name'), uniqueString(resourceGroup().id))]"
                }
            },
            "dependsOn": []
        }
    ],
    "outputs": {
        "returnedIPAddress": {
            "type": "string",
            "value": "[reference(parameters('publicIPAddresses_name')).ipAddress]"
        }
    }
}

De volgende sjabloon een koppeling naar de voorgaande sjabloon.The following template links to the preceding template. Hiermee maakt u drie openbare IP-adressen.It creates three public IP addresses.

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
    },
    "variables": {},
    "resources": [
        {
            "type": "Microsoft.Resources/deployments",
            "apiVersion": "2018-05-01",
            "name": "[concat('linkedTemplate', copyIndex())]",
            "copy": {
                "count": 3,
                "name": "ip-loop"
            },
            "properties": {
              "mode": "Incremental",
              "templateLink": {
                "uri": "[uri(deployment().properties.templateLink.uri, 'static-public-ip.json')]",
                "contentVersion": "1.0.0.0"
              },
              "parameters":{
                  "publicIPAddresses_name":{"value": "[concat('myip-', copyIndex())]"}
              }
            }
        }
    ]
}

Na de implementatie, kunt u de uitvoerwaarden met de volgende PowerShell-script ophalen:After the deployment, you can retrieve the output values with the following PowerShell script:

$loopCount = 3
for ($i = 0; $i -lt $loopCount; $i++)
{
    $name = 'linkedTemplate' + $i;
    $deployment = Get-AzResourceGroupDeployment -ResourceGroupName examplegroup -Name $name
    Write-Output "deployment $($deployment.DeploymentName) returned $($deployment.Outputs.returnedIPAddress.value)"
}

Of Azure CLI-script in een Bash-shell:Or, Azure CLI script in a Bash shell:

#!/bin/bash

for i in 0 1 2;
do
    name="linkedTemplate$i";
    deployment=$(az group deployment show -g examplegroup -n $name);
    ip=$(echo $deployment | jq .properties.outputs.returnedIPAddress.value);
    echo "deployment $name returned $ip";
done

Beveiligen van een externe-sjabloonSecuring an external template

Hoewel de gekoppelde sjabloon extern beschikbaar zijn moet, hoeft niet te worden in het algemeen beschikbaar is voor het publiek.Although the linked template must be externally available, it doesn't need to be generally available to the public. U kunt uw sjabloon toevoegen aan een persoonlijke storage-account die toegankelijk is voor alleen de eigenaar van het opslagaccount.You can add your template to a private storage account that is accessible to only the storage account owner. Vervolgens maakt u een token shared access signature (SAS) waarmee toegang tijdens de implementatie.Then, you create a shared access signature (SAS) token to enable access during deployment. U toevoegen deze SAS-token aan de URI voor de gekoppelde sjabloon.You add that SAS token to the URI for the linked template. Hoewel het token is doorgegeven als een beveiligde tekenreeks, wordt de URI van de gekoppelde sjabloon, met inbegrip van de SAS-token in de implementatiebewerkingen vastgelegd.Even though the token is passed in as a secure string, the URI of the linked template, including the SAS token, is logged in the deployment operations. Als u wilt beperken van blootstelling, instellen dat een verlopen voor het token.To limit exposure, set an expiration for the token.

De parameter-bestand kan ook worden beperkt tot toegang tot en met een SAS-token.The parameter file can also be limited to access through a SAS token.

Op dit moment kunt u geen koppeling maken met een sjabloon in een opslag account dat zich achter een Azure Storage firewallbevindt.Currently, you can't link to a template in a storage account that is behind an Azure Storage firewall.

Het volgende voorbeeld laat zien hoe om door te geven van een SAS-token bij het koppelen aan een sjabloon:The following example shows how to pass a SAS token when linking to a template:

{
  "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "containerSasToken": { "type": "string" }
  },
  "resources": [
    {
      "type": "Microsoft.Resources/deployments",
      "apiVersion": "2018-05-01",
      "name": "linkedTemplate",
      "properties": {
        "mode": "Incremental",
        "templateLink": {
          "uri": "[concat(uri(deployment().properties.templateLink.uri, 'helloworld.json'), parameters('containerSasToken'))]",
          "contentVersion": "1.0.0.0"
        }
      }
    }
  ],
  "outputs": {
  }
}

In PowerShell kunt u een token verkrijgen voor de container en de sjablonen implementeren met de volgende opdrachten.In PowerShell, you get a token for the container and deploy the templates with the following commands. U ziet dat de containerSasToken parameter is gedefinieerd in de sjabloon.Notice that the containerSasToken parameter is defined in the template. Het is geen para meter in de opdracht New-AzResourceGroupDeployment .It isn't a parameter in the New-AzResourceGroupDeployment command.

Set-AzCurrentStorageAccount -ResourceGroupName ManageGroup -Name storagecontosotemplates
$token = New-AzStorageContainerSASToken -Name templates -Permission r -ExpiryTime (Get-Date).AddMinutes(30.0)
$url = (Get-AzStorageBlob -Container templates -Blob parent.json).ICloudBlob.uri.AbsoluteUri
New-AzResourceGroupDeployment -ResourceGroupName ExampleGroup -TemplateUri ($url + $token) -containerSasToken $token

Voor Azure CLI in een Bash-shell, moet u een token verkrijgen voor de container en de sjablonen implementeren met de volgende code:For Azure CLI in a Bash shell, you get a token for the container and deploy the templates with the following code:

#!/bin/bash

expiretime=$(date -u -d '30 minutes' +%Y-%m-%dT%H:%MZ)
connection=$(az storage account show-connection-string \
    --resource-group ManageGroup \
    --name storagecontosotemplates \
    --query connectionString)
token=$(az storage container generate-sas \
    --name templates \
    --expiry $expiretime \
    --permissions r \
    --output tsv \
    --connection-string $connection)
url=$(az storage blob url \
    --container-name templates \
    --name parent.json \
    --output tsv \
    --connection-string $connection)
parameter='{"containerSasToken":{"value":"?'$token'"}}'
az group deployment create --resource-group ExampleGroup --template-uri $url?$token --parameters $parameter

VoorbeeldsjablonenExample templates

De volgende voorbeelden ziet veelvoorkomende toepassingen van gekoppelde sjablonen.The following examples show common uses of linked templates.

Belangrijkste sjabloonMain template Gekoppelde sjabloonLinked template BeschrijvingDescription
Hello WorldHello World Gekoppelde sjabloonlinked template Retourneert de tekenreeks van gekoppelde sjabloon.Returns string from linked template.
Load Balancer met openbare IP-adresLoad Balancer with public IP address Gekoppelde sjabloonlinked template Openbare IP-adres van de gekoppelde sjabloon retourneert en stelt u die waarde in de load balancer.Returns public IP address from linked template and sets that value in load balancer.
Meerdere IP-adressenMultiple IP addresses Gekoppelde sjabloonlinked template Hiermee maakt u meerdere openbare IP-adressen in gekoppelde sjabloon.Creates several public IP addresses in linked template.

Volgende stappenNext steps