0Pricing
Cloud & IT Cert Prep · Leçon

Bicep : l’IaC Azure moderne

Découvrez la syntaxe concise de Bicep, abstraction fortement typée du JSON ARM, convertissez un modèle ARM existant en Bicep et déployez-le avec Azure CLI.

Bicep : l’IaC Azure moderne est une leçon Cloud & IT Cert Prep gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Cloud & IT Cert Prep, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Cloud & IT Cert Prep comprend 4 leçons au total.

Qu'est-ce que Bicep et pourquoi l'utiliser ?

Bicep est un langage propre à un domaine (DSL) développé par Microsoft. Il constitue une alternative concise et fortement typée aux modèles JSON ARM. Bicep est compilé en JSON ARM standard : il utilise donc le même moteur de déploiement ARM et prend en charge tous les types de ressources Azure dès leur disponibilité. Bicep supprime une grande partie du code répétitif nécessaire avec le JSON brut et offre une meilleure sécurité de typage ainsi qu'une meilleure prise en charge d'IntelliSense.

Comparaison de la syntaxe Bicep et du JSON ARM

Le même compte de stockage qui nécessite environ 25 lignes de JSON dans un modèle ARM n'en nécessite qu'environ 8 en Bicep. Bicep élimine '$schema', contentVersion, le conteneur du tableau resources et la syntaxe d'expression verbeuse. Les noms et les types des propriétés restent identiques, car Bicep est une couche d'abstraction directe au-dessus du JSON ARM : il n'y a absolument aucune différence à l'exécution.

// Bicep: deploy a storage account
param storageAccountName string
param location string = resourceGroup().location
param sku string = 'Standard_LRS'

resource storageAccount 'Microsoft.Storage/storageAccounts@2023-01-01' = {
  name: storageAccountName
  location: location
  sku: {
    name: sku
  }
  kind: 'StorageV2'
  properties: {
    supportsHttpsTrafficOnly: true
    minimumTlsVersion: 'TLS1_2'
  }
}

Paramètres et décorateurs dans Bicep

Les paramètres Bicep utilisent la syntaxe concise param name type = defaultValue. Vous pouvez appliquer des décorateurs (préfixés par @) directement au-dessus d'un paramètre afin d'ajouter des contraintes telles que @minLength(), @maxLength(), @allowed() et @description(). Le décorateur @secure() marque un paramètre comme sensible, ce qui équivaut à secureString dans le JSON ARM.

@description('Globally unique name for the storage account')
@minLength(3)
@maxLength(24)
param storageAccountName string

@allowed(['Standard_LRS', 'Standard_GRS', 'Premium_LRS'])
param sku string = 'Standard_LRS'

@secure()
param adminPassword string

Variables et expressions dans Bicep

Les variables Bicep sont déclarées avec le mot-clé var et peuvent contenir n'importe quelle expression, notamment l'interpolation de chaînes à l'aide de la syntaxe '${value}'. L'interpolation de chaînes est l'une des améliorations les plus lisibles par rapport au JSON ARM : plus besoin d'appels à la fonction concat(). Bicep prend également en charge les expressions conditionnelles utilisant l'opérateur ternaire condition ? trueValue : falseValue.

param environment string = 'dev'
param baseName string = 'myapp'

var uniqueSuffix = uniqueString(resourceGroup().id)
var storageAccountName = '${baseName}${environment}${uniqueSuffix}'
var isProd = environment == 'prod'
var skuName = isProd ? 'Standard_GRS' : 'Standard_LRS'

Déclarations de ressources et noms symboliques

Dans Bicep, chaque ressource reçoit un nom symbolique, c'est-à-dire un identifiant utilisé pour la référencer dans le modèle. Le nom symbolique n'est pas identique au nom Azure de la ressource. Utilisez les noms symboliques pour accéder aux propriétés des ressources et établir des dépendances implicites en référençant une ressource à l'intérieur d'une autre, ce qui évite d'avoir à utiliser un tableau dependsOn explicite.

resource vnet 'Microsoft.Network/virtualNetworks@2023-05-01' = {
  name: 'myVNet'
  location: location
  properties: {
    addressSpace: { addressPrefixes: ['10.0.0.0/16'] }
  }
}

// Implicit dependency via symbolic name reference
resource subnet 'Microsoft.Network/virtualNetworks/subnets@2023-05-01' = {
  parent: vnet  // Bicep knows to create vnet first
  name: 'mySubnet'
  properties: {
    addressPrefix: '10.0.1.0/24'
  }
}

Sorties dans Bicep

Les sorties Bicep se déclarent avec le mot-clé output, suivi du nom, du type et de la valeur de la sortie. Vous pouvez référencer les propriétés d’une ressource déployée à l’aide de son nom symbolique et de la notation par points, ce qui est bien plus lisible que la fonction reference() d’ARM. Les sorties sont essentielles pour transmettre des valeurs entre les appels de modules Bicep.

output storageAccountName string = storageAccount.name
output blobEndpoint string = storageAccount.properties.primaryEndpoints.blob
output storageAccountId string = storageAccount.id

Modules Bicep

Les modules Bicep sont l’équivalent des modèles liés dans ARM JSON et vous permettent de diviser votre infrastructure en composants réutilisables. Un module est simplement un autre fichier .bicep. Vous le référencez à l’aide du mot-clé module, lui transmettez des paramètres et utilisez ses sorties. Les modules peuvent également être publiés dans un Azure Container Registry et utilisés depuis celui-ci afin d’être réutilisés par toute l’équipe.

// main.bicep — consuming a storage module
module storage './modules/storage.bicep' = {
  name: 'storageDeploy'
  params: {
    storageAccountName: 'myuniquestorage'
    location: location
    sku: 'Standard_LRS'
  }
}

// Reference module output in parent template
output blobUri string = storage.outputs.blobEndpoint

Convertir des modèles ARM en Bicep

Si vous disposez déjà de modèles ARM JSON existants, le CLI Bicep peut les décompiler en Bicep à l’aide de bicep decompile. Le résultat peut nécessiter un nettoyage manuel, mais il constitue un excellent point de départ. Microsoft propose également un environnement de test en ligne à l’adresse aka.ms/bicepdemo, où vous pouvez coller du code ARM JSON et voir l’équivalent Bicep en temps réel.

# Install the Bicep CLI (or use it via Azure CLI)
az bicep install
az bicep upgrade

# Decompile existing ARM JSON to Bicep
az bicep decompile --file azuredeploy.json
# Produces azuredeploy.bicep in the same directory

# Compile Bicep to ARM JSON (for inspection)
az bicep build --file main.bicep

Déployer Bicep avec Azure CLI

Azure CLI prend directement en charge les fichiers Bicep : vous n’avez pas besoin de les compiler manuellement en ARM JSON avant le déploiement. Transmettez le chemin du fichier .bicep à az deployment group create avec l’option --template-file, et le CLI le compile de manière transparente. Les mêmes sous-commandes validate et what-if fonctionnent avec les fichiers Bicep exactement comme avec ARM JSON.

# Deploy a Bicep file directly
az deployment group create \
  --resource-group MyRG \
  --template-file main.bicep \
  --parameters storageAccountName=myprodstore environment=prod

# What-if preview with Bicep
az deployment group what-if \
  --resource-group MyRG \
  --template-file main.bicep \
  --parameters storageAccountName=myprodstore environment=prod

Boucles et conditions dans Bicep

Bicep prend en charge les boucles de ressources avec la syntaxe for ... in afin de créer plusieurs instances d’une ressource à partir d’un paramètre tableau, ce qui évite les duplications dues au copier-coller. Le mot-clé if permet le déploiement conditionnel de ressources : une ressource n’est incluse que lorsqu’une condition donnée est vraie. Ces deux fonctionnalités sont compilées respectivement en constructions ARM copy et condition.

// Loop: create multiple storage accounts
param storageNames array = ['alpha', 'beta', 'gamma']

resource stores 'Microsoft.Storage/storageAccounts@2023-01-01' = [for name in storageNames: {
  name: '${name}${uniqueString(resourceGroup().id)}'
  location: location
  sku: { name: 'Standard_LRS' }
  kind: 'StorageV2'
}]

// Condition: only deploy in prod
param deployKeyVault bool = false

resource kv 'Microsoft.KeyVault/vaults@2023-07-01' = if (deployKeyVault) {
  name: 'myKeyVault'
  location: location
  properties: { sku: { family: 'A', name: 'standard' }, tenantId: subscription().tenantId, accessPolicies: [] }
}

Outils et analyse du code Bicep

L’extension Bicep pour Visual Studio Code fournit IntelliSense avancé, la vérification des types et la mise en évidence des erreurs directement dans le code pendant la saisie. Le CLI Bicep inclut un analyseur de code qui recherche les écarts par rapport aux bonnes pratiques, tels que les paramètres inutilisés, les descriptions manquantes et les versions d’API incorrectes. Exécutez az bicep lint --file main.bicep dans votre pipeline d’intégration continue afin de détecter les problèmes avant le déploiement.

# Run the Bicep linter
az bicep lint --file main.bicep

# Format a Bicep file
az bicep format --file main.bicep

# Generate resource type documentation
az bicep generate-params --file main.bicep --output-format json

Vérification rapide

Vérifiez votre compréhension des concepts Microsoft Azure Fundamentals (AZ-900) présentés dans cette leçon.

Récapitulatif de la leçon

Dans cette leçon, vous avez appris que Bicep est une abstraction concise et fortement typée d’ARM JSON qui se compile en modèles ARM standard, que les modules et les boucles permettent de créer du code d’infrastructure réutilisable et DRY, et que l’Azure CLI déploie directement les fichiers Bicep en prenant en charge le même processus validate/what-if/deploy. Nous allons maintenant découvrir Terraform sur Azure.

Questions Fréquemment Posées

La leçon « Bicep : l’IaC Azure moderne » est-elle gratuite ?

Oui — le texte complet de « Bicep : l’IaC Azure moderne » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Cloud & IT Cert Prep, passe à CoddyKit PRO. Le cours Cloud & IT Cert Prep comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Bicep : l’IaC Azure moderne » ?

Découvrez la syntaxe concise de Bicep, abstraction fortement typée du JSON ARM, convertissez un modèle ARM existant en Bicep et déployez-le avec Azure CLI. Tu pratiques Cloud & IT Cert Prep avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Cloud & IT Cert Prep ?

Aucune expérience préalable n'est requise. Cloud & IT Cert Prep sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Bicep : l’IaC Azure moderne » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Cloud & IT Cert Prep ?

Oui. Chaque leçon Cloud & IT Cert Prep inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Fonctionnement d’Azure Resource Manager
  2. Écriture de modèles ARM
  3. Bicep : l’IaC Azure moderne
  4. Terraform sur Azure
← Retour à Cloud & IT Cert Prep