Fichiers de paramètres extensibles dans Bicep

En utilisant des fichiers de paramètres extensibles Bicep, vous pouvez définir des paramètres une seule fois dans un fichier de paramètres de base et les réutiliser dans plusieurs fichiers de paramètres dérivés. Cette approche améliore considérablement la réutilisation des paramètres et garantit la cohérence entre vos déploiements. Bicep CLI version 0.44.1 et les versions ultérieures prennent en charge les fichiers de paramètres extensibles, ainsi que les mots-clés extends et base.

Un fichier de paramètres dérivé ne peut étendre qu’un seul fichier de paramètres de base. Il ne peut contenir qu’une extends seule instruction. Toutefois, vous pouvez créer des fichiers de paramètres imbriqués en chaînant des extensions sur plusieurs fichiers. Pour plus d’informations, consultez fichiers de paramètres imbriqués.

L’instruction extends hérite uniquement des affectations de paramètres.

• Vous pouvez définir des variables dans le fichier de paramètres de base pour calculer ses valeurs de paramètre, mais ces variables ne sont pas exposées aux fichiers de paramètres dérivés.
• Vous pouvez définir des types définis par l’utilisateur dans des fichiers de paramètres. Vous pouvez également importer des types définis par l’utilisateur dans un fichier Bicep. Toutefois, ces types définis par l’utilisateur ne sont pas exposés aux fichiers de paramètres dérivés.
• Vous ne pouvez pas déclarer de fonctions définies par l’utilisateur directement dans un fichier de paramètres. Toutefois, vous pouvez les importer dans un fichier de paramètres. Ces fonctions ne sont pas exposées aux fichiers de paramètres dérivés.

Étendre le fichier de paramètres

Par défaut, les paramètres que vous définissez dans un fichier de paramètres dérivé remplacent complètement ceux du fichier de paramètres de base. Pour fusionner au lieu de remplacer, utilisez le mot clé base avec une syntaxe d’étendue d’objet ou de tableau. Pour plus d’informations, consultez Accéder aux paramètres parents.

Utilisez l’instruction dans les using none fichiers de paramètres de base pour indiquer au compilateur de ne pas les lier ou de les valider par rapport à un fichier Bicep spécifique.

L’exemple suivant montre comment fonctionnent les fichiers de paramètres extensibles dans Bicep.

Votre modèle Bicep principal, main.bicep, définit les paramètres que votre déploiement accepte.

param namePrefix string
param location string
param tags object

Un fichier de paramètres de base, base.bicepparamque vous pouvez réutiliser dans plusieurs déploiements et environnements.

using none
// Notice that the first line of this .bicepparam file declares `using none` which tells the compiler not to validate this against any particular .bicep file.

param namePrefix = 'Prod'
param location = 'westus'
param tags = {
  environment: 'dev'
  owner: 'platform'
}

Fichier de paramètres étendu, derived.bicepparamqui s’appuie sur le fichier de paramètres de base. Il fait référence au fichier Bicep et au fichier de paramètres de base. Les valeurs que vous définissez ici remplacent les précédentes.

using 'main.bicep'

extends 'base.bicepparam'

param namePrefix = 'Dev'
param tags = {
  ...base.tags        // inherit the object from the base file
  environment: 'prod' // override a single property
  region: 'westus2'   // add new data
}

Dans cet exemple, les valeurs de paramètre sont appliquées dans des couches avec un ordre de priorité clair. Le main.bicep fichier déclare des paramètres et peut fournir des valeurs par défaut. Un fichier dérivé.bicepparam peut remplacer les valeurs définies dans un fichier de base.bicepparam , et les valeurs de paramètre affectées finales sont prioritaires sur les valeurs par défaut définies dans le modèle cible. Les valeurs résolues sont les suivantes :

Accéder aux paramètres parent

Pour utiliser le base mot clé, votre fichier de paramètres dérivé doit inclure une extends clause. Cette clause déverrouille base en tant qu’identificateur. Vous pouvez donc accéder à tous les paramètres parents en tant que propriétés. Si vous essayez d’utiliser base sans extends clause, vous obtenez une erreur.

Vous pouvez combiner l’opérateur de propagation (...) avec base pour étendre ou fusionner des types de données complexes. Cette approche vous permet de copier des valeurs de tableau ou d’objet existantes à partir du fichier parent et de les modifier sans taper la structure de données entière. L’opérateur de propagation est strictement limité aux objets et tableaux. Si vous essayez de répartir une valeur primitive, telle qu’une chaîne, un entier ou une valeur booléenne, vous provoquez un échec de compilation.

Toutes les valeurs substituées doivent correspondre au type de données exact attendu par le paramètre cible. L’approvisionnement d’un type incompatible entraîne une erreur de type pendant la compilation.

Le fichier Bicep main.bicep :

param app object
param locations array
param fullName string

Le fichier de paramètres de base base.bicepparam :

using none

param app = {
  name: 'demo'
  tags: {
    owner: 'platform'
    environment: 'dev'
  }
}
param locations = ['westus', 'eastus']

Le fichier de paramètres dérivé derived.bicepparam :

using './main.bicep'
extends './base.bicepparam'

// Merge objects
param app = {
  ...base.app
  tags: {
    ...base.app.tags
    environment: 'prod'
    costCenter: '1234'
  }
}

// Merge arrays
param locations = [...base.locations, 'centralus']

// Use base in expressions or variables
var suffix = '-api'
param fullName = '${base.app.name}${suffix}'

Les valeurs résolues sont les suivantes :

Fichiers de paramètres imbriqués

Bien qu’un fichier de paramètres dérivé ne puisse comporter qu’une seule instruction extends, Bicep vous permet de créer des hiérarchies à plusieurs niveaux en chaînant séquentiellement des fichiers de paramètres (fichier de paramètres A $\rightarrow$ fichier de paramètres B $\rightarrow$ fichier de paramètres C).

Cette structure est utile pour organiser les déploiements d’entreprise. Vous pouvez définir les valeurs par défaut globales à la racine, remplacer les paramètres à l’échelle de l’environnement dans le niveau intermédiaire et spécifier des configurations localisées spécifiques aux ressources au niveau feuille.

Lorsque vous générez une chaîne, tout fichier de paramètres intermédiaire ou racine de la séquence doit inclure l’instruction using none . Cette instruction signale au compilateur Bicep que le fichier agit strictement comme une couche de configuration et ne lie pas directement à un modèle de déploiement spécifique.bicep.

L’exemple suivant montre comment configurer une chaîne à trois niveaux pour configurer une disposition de ressource Azure, en passant des paramètres d’organisation globaux vers un environnement de développement localisé spécifique.

Le fichier Bicep (compute.bicep)

param primaryLocation string

param globalTags object 
param environmentTags object
param resourceTags object

param skuName string
param vmSku string
param vmName string
...

Le niveau racine : les valeurs par défaut globales (global.bicepparam) établissent les propriétés de base utilisées dans l’ensemble de l’organisation. Il utilise using none parce qu’il s’agit d’une base de configuration purement.

using none

// Global baseline tags applied to every single resource
param globalTags = {
  BillingUnit: 'Enterprise-IT'
  DataClassification: 'Confidential'
}

// Default regional pair
param primaryLocation = 'eastus'

Le niveau intermédiaire : les paramètres d’environnement (dev-defaults.bicepparam) héritent des propriétés globales, remplacent le type d’environnement et ajoutent des configurations spécifiques à l’environnement. Comme il s’agit d’une couche intermédiaire, elle utilise using noneégalement .

using none
extends './global.bicepparam'

// Inherit global tags and inject the environment designation
param environmentTags = {
  ...base.globalTags
  Environment: 'Development'
}

// Override region for low-cost development testing
param primaryLocation = 'westus'

// Tier-specific infrastructure sizes
param skuName = 'Standard_D2s_v5'

Niveau feuille : déploiement ciblé (compute.dev.bicepparam) cible un déploiement de charge de travail spécifique. Il se connecte directement au modèle réel d’infrastructure Bicep via l’instruction standard using, en héritant de l’intégralité de l’état combiné de la chaîne.

extends './dev-defaults.bicepparam'
using './compute.bicep' // Binds the final resolved values to the template

// Combine all inherited layers into the final parameters expected by compute.bicep
param resourceTags = {
  ...base.environmentTags
  Workload: 'Web-FrontEnd'
}

// Use inherited environment SKU directly, or override it if needed
param vmSku = base.skuName

// Explicit deployment property
param vmName = 'vm-web-dev-01'

Contenu connexe

• Pour en savoir plus sur les fichiers de paramètres Bicep, consultez fichier de paramètres Bicep.
• Pour en savoir plus sur using et using none, consultez Utilisation et utilisation d’instructions none.
• Pour en savoir plus sur l’opérateur de propagation, consultez l’opérateur Spread.