In the world of Azure infrastructure as code, Azure Bicep has emerged as a key player, simplifying the deployment of Azure resources. A critical aspect of Bicep's functionality revolves around the effective use of parameters. Parameters in Bicep allow for creating dynamic, reusable, and flexible templates. This comprehensive guide will delve into the nuances of using parameters in Azure Bicep, focusing on their roles in root templates, modules, and parameter files.

Understanding Parameters in Azure Bicep

Parameters in Azure Bicep act as placeholders for values that are supplied when the template is deployed. They enhance template reusability and allow for customization based on the deployment environment or specific requirements.

Root main.bicep Parameters

The root main.bicep file, typically the starting point of a Bicep deployment, defines the overarching parameters for the deployment. These parameters serve as the primary inputs and can be configured with default values or overridden during deployment.

Module Parameters

Modules in Bicep are like functions in programming languages – they encapsulate a set of resource definitions and can be reused. Parameters in modules allow for passing specific values from the root template or other modules, ensuring modularity and reusability.

Parameters in Bicep Parameter Files

Parameter files (usually with .dev.bicepparams extension) externalize the values for parameters, making it easier to manage different configurations for different environments (like development, testing, production).

Case Study: Deploying a Storage Account

To illustrate the practical application of parameters in Bicep, let's consider a scenario where we need to deploy an Azure storage account.

1. Root main.bicep File

Our journey begins with the root main.bicep file, where we define the parameters for our deployment.

// Root main.bicep - main deployment
param storageAccountName string
param location string = 'eastus'
param sku string = 'Standard_LRS'
param kind string = 'StorageV2'

module storageModule 'storageModule.bicep' = {
  name: 'storageDeployment'
  params: {
    accountName: storageAccountName
    accountLocation: location
    accountSku: sku
    accountKind: kind


  • Parameters: storageAccountName, location, sku, and kind are defined with the ability to set default values.
  • Module Call: The storageModule is invoked with specific parameters passed to it.

2. Module storageModule.bicep File

Next, we look at the storageModule.bicep file, which contains the logic for deploying the storage account.

// storageModule.bicep
param accountName string
param accountLocation string
param accountSku string
param accountKind string

resource storageAccount 'Microsoft.Storage/storageAccounts@2021-04-01' = {
  name: accountName
  location: accountLocation
  sku: {
    name: accountSku
  kind: accountKind


  • Module Parameters: This module receives parameters from the root file. These parameters are used to define the storage account's properties.
  • Resource Definition: The storage account is defined with properties like name, location, sku, and kind based on the module's parameters.

3. Development Parameter File dev.bicepparams

For different environments, parameter files come into play. Here's an example of a parameter file for the development environment.

using 'main.bicep'

// Parameters for the main.bicep file
param storageAccountName = 'devstorageaccount123'
param location = 'westus'
param sku = 'Standard_GRS'
param kind = 'BlobStorage'


  • Parameter Values: This file provides specific values to be used during the deployment of the Bicep template in a development environment.
  • Overriding Defaults: The values here will override any default values set in the main.bicep file.

Bringing It All Together

When the template is deployed, parameters flow from the parameter file (or command line) to the root main.bicep, and then to the module. This flow allows for a flexible and customizable deployment process.

Advanced Use Case: Multi-Region Deployment

To further explore the versatility of parameters, let's consider a multi-region deployment scenario.

Modules with Defaults

Consider two modules: storageModule.bicep and networkModule.bicep, each with a default region set within.

// Example of module with default region storageModule.bicep
param location string = 'eastus' // Default location
// Resource definitions follow...

Root main.bicep with Project-Specific Defaults

In the root main.bicep, we override these defaults for a specific deployment.

// Example of module with default region networkModule.bicep
param location string = 'centralus' // Overriding default for all resources

// Module invocations follow...

Use Case Explanation

  • Modules: Each module has its own default region, making them self-contained.
  • Root Template: Overrides the module defaults for a specific deployment, ensuring consistency across resources.


Azure Bicep's parameterization capability offers immense flexibility, making infrastructure as code more dynamic and adaptable.

By mastering the use of parameters in root templates, modules, and parameter files, you can build sophisticated, scalable, and maintainable Azure infrastructure deployments.

I hope this blog post provides a detailed and clear understanding of working with parameters in Azure Bicep, helping both beginners and experienced practitioners in their cloud infrastructure endeavors.