Utilisation de modèles liés et imbriqués durant le déploiement de ressources AzureUsing linked and nested templates when deploying Azure resources

Pour déployer votre solution, vous pouvez utiliser un modèle unique ou un modèle principal avec de nombreux modèles associés.To deploy your solution, you can use either a single template or a main template with many related templates. Le modèle associé peut être un fichier distinct lié à partir du modèle principal, ou un modèle imbriqué dans le modèle principal.The related template can be either a separate file that is linked to from the main template, or a template that is nested within the main template.

Pour les solutions petites et moyennes, un modèle unique est plus facile à comprendre et à gérer.For small to medium solutions, a single template is easier to understand and maintain. Vous pouvez voir toutes les ressources et valeurs dans un même fichier.You can see all the resources and values in a single file. Pour les scénarios avancés, les modèles liés vous permettent de diviser la solution en composants ciblés et de réutiliser des modèles.For advanced scenarios, linked templates enable you to break down the solution into targeted components, and reuse templates.

Lorsque vous utilisez des modèles liés, vous créez un modèle principal qui reçoit les valeurs de paramètre au cours du déploiement.When using linked templates, you create a main template that receives the parameter values during deployment. Le modèle principal contient tous les modèles liés et transmet des valeurs à ces modèles en fonction des besoins.The main template contains all the linked templates and passes values to those templates as needed.

Pour obtenir un tutoriel, consultez Tutoriel : Créer des modèles Azure Resource Manager liés.For a tutorial, see Tutorial: create linked Azure Resource Manager templates.

Notes

Pour les modèles liés ou imbriqués, vous pouvez uniquement utiliser le mode de déploiement Incremental.For linked or nested templates, you can only use Incremental deployment mode.

Pour créer un lien vers un autre modèle, ajoutez une ressource de déploiement à votre modèle principal.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>
    }
  }
]

Les propriétés que vous fournissez pour la ressource de déploiement varient selon que vous établissez la liaison à un modèle externe ou que vous imbriquez un modèle inclus dans le modèle principal.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.

Modèle imbriquéNested template

Pour imbriquer le modèle dans le modèle principal, utilisez la propriété template et spécifiez la syntaxe du modèle.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"
            }
          }
        ]
      }
    }
  }
]

Notes

Pour les modèles imbriqués, vous ne pouvez pas utiliser les paramètres ou variables définis dans le modèle imbriqué.For nested templates, you cannot use parameters or variables that are defined within the nested template. Vous pouvez en revanche utiliser les paramètres et variables du modèle principal.You can use parameters and variables from the main template. Dans l’exemple précédent, [variables('storageName')] récupère une valeur du modèle principal, et non du modèle imbriqué.In the preceding example, [variables('storageName')] retrieves a value from the main template, not the nested template. Cette restriction ne s'applique pas aux modèles externes.This restriction does not apply to external templates.

Pour les deux ressources définis à l’intérieur d’un modèle imbriqué et une ressource dépend de l’autre, la valeur de la dépendance est simplement le nom de la ressource dépendante :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')]"
],

Vous ne pouvez pas utiliser la fonction reference dans la section outputs d’un modèle imbriqué.You can't use the reference function in the outputs section of a nested template. Pour renvoyer les valeurs d’une ressource déployée dans un modèle imbriqué, convertissez votre modèle imbriqué en modèle lié.To return the values for a deployed resource in a nested template, convert your nested template to a linked template.

Le modèle imbriqué nécessite les mêmes propriétés qu’un modèle standard.The nested template requires the same properties as a standard template.

Modèle externe et paramètres externesExternal template and external parameters

Pour établir un lien à un modèle externe et un fichier de paramètres, utilisez templateLink et parametersLink.To link to an external template and parameter file, use templateLink and parametersLink. Quand vous établissez un lien à un modèle, le service Resource Manager doit être en mesure d’y accéder.When linking to a template, the Resource Manager service must be able to access it. Vous ne pouvez pas spécifier un fichier local ni un fichier uniquement disponible sur votre réseau local.You can't specify a local file or a file that is only available on your local network. Vous pouvez seulement fournir une valeur URI qui inclut soit http soit https.You can only provide a URI value that includes either http or https. Une possibilité consiste à placer votre modèle lié dans un compte de stockage et à utiliser l’URI de cet élément.One option is to place your linked template in a storage account, and use the URI for that item.

"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"
    }
    }
  }
]

Vous ne devez pas fournir la propriété contentVersion pour le modèle ou les paramètres.You don't have to provide the contentVersion property for the template or parameters. Si vous ne fournissez pas une valeur de version du contenu, la version actuelle du modèle est déployée.If you don't provide a content version value, the current version of the template is deployed. Si vous fournissez une valeur pour la version du contenu, elle doit correspondre à la version du modèle lié ; sinon, le déploiement échoue avec une erreur.If you provide a value for content version, it must match the version in the linked template; otherwise, the deployment fails with an error.

Modèle externe et paramètres inclusExternal template and inline parameters

Ou bien, vous pouvez fournir le paramètre inclus.Or, you can provide the parameter inline. Vous ne pouvez pas utiliser à la fois des paramètres inline et un lien vers un fichier de paramètres.You can't use both inline parameters and a link to a parameter file. Si parametersLink et parameters sont spécifiés tous les deux, le déploiement échoue.The deployment fails with an error when both parametersLink and parameters are specified.

Pour passer une valeur du modèle principal au modèle lié, utilisez des paramètres.To pass a value from the main template to the linked template, use parameters.

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

À l’aide de la copieUsing copy

Pour créer plusieurs instances d’une ressource avec un modèle imbriqué, ajoutez l’élément de copie au niveau de la Microsoft.Resources/Deployments ressource.To create multiple instances of a resource with a nested template, add the copy element at the level of the Microsoft.Resources/deployments resource.

Le modèle de l’exemple suivant montre comment utiliser copy avec un modèle imbriqué.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
            //}
          }
        ]
      }
    }
  }
]

Les exemples précédents représentaient des valeurs d’URL codées en dur pour les liens de modèle.The previous examples showed hard-coded URL values for the template links. Cette approche peut fonctionner pour un modèle simple, mais elle ne fonctionne pas bien pour un grand ensemble de modèles modulaires.This approach might work for a simple template but it doesn't work well when working with a large set of modular templates. Au lieu de cela, vous pouvez créer une variable statique qui stocke une URL de base pour le modèle principal, avant de créer dynamiquement les URL pour les modèles liés à partir de cette URL de base.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. Cette approche permet notamment de déplacer ou de répliquer facilement le modèle. En effet, il vous suffit de modifier la variable statique dans le modèle principal.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. Le modèle principal transmet les URI appropriés au modèle décomposé.The main template passes the correct URIs throughout the decomposed template.

L’exemple suivant indique comment utiliser une URL de base afin de créer deux URL pour des modèles liés (sharedTemplateUrl et 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')]"
}

Vous pouvez également utiliser deployment() pour obtenir l’URL de base pour le modèle actuel, qui permet d’obtenir l’URL d’autres modèles dans le même emplacement.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. Cette approche est pratique si l’emplacement des modèles change ou si vous voulez éviter de coder en dur les URL dans le fichier du modèle.This approach is useful if your template location changes or you want to avoid hard coding URLs in the template file. La propriété templateLink n’est renvoyée qu’en cas de liaison à un modèle distant avec une URL.The templateLink property is only returned when linking to a remote template with a URL. Si vous utilisez un modèle local, cette propriété n’est pas disponible.If you're using a local template, that property isn't available.

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

Obtenir des valeurs du modèle liéGet values from linked template

Pour obtenir une valeur de sortie d’un modèle lié, récupérez la valeur de propriété à l’aide d’une syntaxe comme : "[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]".

Lors de l’obtention d’une propriété de sortie à partir d’un modèle lié, le nom de propriété ne peut pas inclure de tiret.When getting an output property from a linked template, the property name can't include a dash.

Les exemples suivants montrent comment faire référence à un modèle lié pour récupérer une valeur de sortie.The following examples demonstrate how to reference a linked template and retrieve an output value. Le modèle lié retourne un message simple.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"
        }
    }
}

Le modèle principal déploie le modèle lié et obtient la valeur retournée.The main template deploys the linked template and gets the returned value. Remarquez qu’il fait référence à la ressource de déploiement par son nom et qu’il utilise le nom de la propriété retournée par le modèle lié.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]"
        }
    }
}

Comme pour d’autres types de ressources, vous pouvez définir des dépendances entre le modèle lié et d’autres ressources.Like other resource types, you can set dependencies between the linked template and other resources. Par conséquent, lorsque d’autres ressources requièrent une valeur de sortie provenant du modèle lié, veillez à ce que ce dernier soit déployé avant celles-ci.Therefore, when other resources require an output value from the linked template, make sure the linked template is deployed before them. Sinon, lorsque le modèle lié s’appuie sur d’autres ressources, vérifiez que celles-ci sont déployées avant le modèle lié.Or, when the linked template relies on other resources, make sure other resources are deployed before the linked template.

L’exemple suivant montre un modèle qui déploie une adresse IP publique et retourne l’ID de ressource :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'))]"
        }
    }
}

Pour utiliser l’adresse IP publique du modèle précédent lors du déploiement d’un équilibreur de charge, établissez un lien vers le modèle et ajoutez une dépendance vis-à-vis de la ressource de déploiement.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. L’adresse IP publique sur l’équilibreur de charge est définie sur la valeur de sortie du modèle lié.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')]"}
                }
            }
        }
    ]
}

Modèles liés et imbriqués dans l’historique de déploiementLinked and nested templates in deployment history

Resource Manager traite chaque modèle comme un déploiement séparé dans l’historique de déploiement.Resource Manager processes each template as a separate deployment in the deployment history. Par conséquent, un modèle principal doté de trois modèles liés ou imbriqués s’affiche dans l’historique de déploiement en tant que :Therefore, a main template with three linked or nested templates appears in the deployment history as:

Historique de déploiement

Vous pouvez utiliser ces entrées distinctes dans l’historique pour récupérer les valeurs de sortie après le déploiement.You can use these separate entries in the history to retrieve output values after the deployment. Le modèle suivant crée une adresse IP publique et renvoie l’adresse IP :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]"
        }
    }
}

Le modèle suivant est lié au modèle précédent.The following template links to the preceding template. Il crée trois adresses IP publiques.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())]"}
              }
            }
        }
    ]
}

Après le déploiement, vous pouvez récupérer les valeurs de sortie avec le script PowerShell suivant :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)"
}

Vous pouvez aussi utiliser un script Azure CLI dans un interpréteur de commandes Bash :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

Sécurisation d’un modèle externeSecuring an external template

Même si le modèle lié doit être disponible en externe, il n’a pas besoin d’être accessible au public.Although the linked template must be externally available, it doesn't need to be generally available to the public. Vous pouvez ajouter votre modèle dans un compte de stockage privé, uniquement accessible au propriétaire du compte de stockage.You can add your template to a private storage account that is accessible to only the storage account owner. Ensuite, vous créez un jeton de signature d’accès partagé (SAP) pour autoriser l’accès en cours de déploiement.Then, you create a shared access signature (SAS) token to enable access during deployment. Vous ajoutez ce jeton SAP à l’URI pour le modèle lié.You add that SAS token to the URI for the linked template. Même si le jeton est transmis sous forme de chaîne sécurisée, l’URI du modèle lié, y compris le jeton SAP, est enregistré dans les opérations de déploiement.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. Pour limiter l’exposition, définissez un délai d’expiration pour le jeton.To limit exposure, set an expiration for the token.

Le fichier de paramètres peut également être limité à l’accès avec un jeton SAP.The parameter file can also be limited to access through a SAS token.

L’exemple suivant montre comment passer un jeton SAP lors de la liaison à un modèle :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": {
  }
}

Dans PowerShell, vous obtenez un jeton pour le conteneur et déployez les modèles avec les commandes suivantes.In PowerShell, you get a token for the container and deploy the templates with the following commands. Notez que le paramètre containerSasToken est défini dans le modèle.Notice that the containerSasToken parameter is defined in the template. Il ne s'agit pas d'un paramètre de la commande 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

Avec un script Azure CLI dans un interpréteur de commandes Bash, vous obtenez un jeton pour le conteneur et vous déployez les modèles avec le code suivant :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

Exemples de modèlesExample templates

Les exemples suivants montrent des utilisations courantes des modèles liés.The following examples show common uses of linked templates.

Modèle principalMain template Modèle liéLinked template DescriptionDescription
Hello WorldHello World modèle liélinked template Retourne une chaîne du modèle lié.Returns string from linked template.
Équilibreur de charge avec adresse IP publiqueLoad Balancer with public IP address modèle liélinked template Retourne l’adresse IP publique du modèle lié et affecte cette valeur à l’équilibreur de charge.Returns public IP address from linked template and sets that value in load balancer.
Plusieurs adresses IPMultiple IP addresses modèle liélinked template Crée plusieurs adresses IP publiques dans le modèle lié.Creates several public IP addresses in linked template.

Étapes suivantesNext steps