Bicep

https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep
Admin
Bicep is a declarative language for deploying Azure resources as an alternative to JSON for...
Tokens:466,971
Snippets:3,991
Trust Score:10
Update:1 week ago
Show doc for...
Tokens:
Raw
### empty function in quickstart template for virtual network diagnostic logs

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/bicep-functions-array

Extracted from a quickstart template, this example uses `empty(dnsServers)` in a conditional expression to set `dhcpOptions` to `null` when the `dnsServers` array is empty.

```bicep
@description('Array containing DNS Servers')
param dnsServers array = []

...

resource vnet 'Microsoft.Network/virtualNetworks@2025-01-01' = {
  name: vnetName
  location: location
  properties: {
    addressSpace: {
      addressPrefixes: vnetAddressSpace
    }
    dhcpOptions: empty(dnsServers) ? null : {
      dnsServers: dnsServers
    }
    ...
  }
}

```

--------------------------------

### Failing example: VM with preview image

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/linter-rule-use-stable-vm-image

This Bicep example fails the 'use-stable-vm-image' rule because the imageReference properties contain 'preview'.

```bicep
param location string = resourceGroup().location

resource vm 'Microsoft.Compute/virtualMachines@2025-04-01' = {
  name: 'virtualMachineName'
  location: location
  properties: {
    storageProfile: {
      imageReference: {
        offer: 'WindowsServer-preview'
        sku: '2019-Datacenter-preview'
        version: 'preview'
      }
    }
  }
}

```

--------------------------------

### Failing example: reference() with unrecognized resource type

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/linter-rule-use-recognized-resource-type

This example fails the linter because 'Microsoft.Foo/bar' is not a recognized resource type.

```bicep
output foo object = reference('Microsoft.Foo/bar', '2020-01-01')

```

--------------------------------

### bicep/compile params example

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/bicep-cli-jsonrpc

Example params for bicep/compile, specifying the path to the .bicep file.

```JSON
{
  "path": "/path/to/main.bicep"
}
```

--------------------------------

### bicep/version result example

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/bicep-cli-jsonrpc

Example result for bicep/version, showing the version property.

```JSON
{
  "version": "0.24.211"
}
```

--------------------------------

### ARMClient: Get deployment script example

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/deployment-script-bicep

Example using ARMClient to get a deployment script resource. ARMClient is not a supported Microsoft tool. Replace the subscription ID, resource group, and deployment script name with your own.

```powershell
armclient login
armclient get /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/myrg/providers/microsoft.resources/deploymentScripts/myDeployementScript?api-version=2020-10-01
```

--------------------------------

### Deployment output showing provisioningState

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/deploy-cli

Example output from a successful deployment, showing the provisioningState as Succeeded.

```json
"provisioningState": "Succeeded",

```

--------------------------------

### Deployment stack creation output (JSON)

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/quickstart-create-deployment-stacks

Example output from creating a deployment stack. Shows the stack properties including provisioningState 'succeeded', managed resources, and denySettings. The output is similar to what is returned by the deployment command.

```json
{
  "actionOnUnmanage": {
    "managementGroups": "detach",
    "resourceGroups": "detach",
    "resources": "detach"
  },
  "bypassStackOutOfSyncError": null,
  "correlationId": "63743f58-a251-4d18-8449-4a37b9885aad",
  "debugSetting": null,
  "deletedResources": [],
  "denySettings": {
    "applyToChildScopes": false,
    "excludedActions": null,
    "excludedPrincipals": null,
    "mode": "none"
  },
  "deploymentId": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/demoRg/providers/Microsoft.Resources/deployments/demoStack-2501151922xo8",
  "deploymentScope": null,
  "description": null,
  "detachedResources": [],
  "duration": "PT31.9923013S",
  "error": null,
  "failedResources": [],
  "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/demoRg/providers/Microsoft.Resources/deploymentStacks/demoStack",
  "location": null,
  "name": "demoStack",
  "outputs": null,
  "parameters": {},
  "parametersLink": null,
  "provisioningState": "succeeded",
  "resourceGroup": "demoRg",
  "resources": [
    {
      "denyStatus": "none",
      "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/demoRg/providers/Microsoft.Network/virtualNetworks/vnetqci7hnvgit6zm",
      "resourceGroup": "demoRg",
      "status": "managed"
    },
    {
      "denyStatus": "none",
      "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/demoRg/providers/Microsoft.Storage/storageAccounts/storeqci7hnvgit6zm",
      "resourceGroup": "demoRg",
      "status": "managed"
    }
  ],
  "systemData": {
    "createdAt": "2025-01-15T19:07:05.542588+00:00",
    "createdBy": "johndoe@contoso.com",
    "createdByType": "User",
    "lastModifiedAt": "2025-01-15T19:07:05.542588+00:00",
    "lastModifiedBy": "johndoe@contoso.com",
    "lastModifiedByType": "User"
  },
  "tags": {},
  "template": null,
  "templateLink": null,
  "type": "Microsoft.Resources/deploymentStacks"
}
```

--------------------------------

### Bicep file example for Paste JSON as Bicep

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/visual-studio-code

A Bicep file that defines a storage account with parameters and output. This is the starting point for the Paste JSON as Bicep example.

```bicep
@description('Storage Account type')
@allowed([
  'Standard_LRS'
  'Standard_GRS'
  'Standard_ZRS'
  'Premium_LRS'
])
param storageAccountsku string = 'Standard_LRS'

@description('Location for all resources.')
param location string = resourceGroup().location

var storageAccountName = '${uniqueString(resourceGroup().id)}storage'

resource storageAccount 'Microsoft.Storage/storageAccounts@2025-06-01' = {
  name: storageAccountName
  location: location
  sku: {
    name: storageAccountsku
  }
  kind: 'StorageV2'
  tags: {
    ObjectName: storageAccountName
  }
  properties: {}
}

output storageAccountName string = storageAccountName

```

--------------------------------

### JSON: Example output of deployment()

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/bicep-functions-deployment

The deployment() function returns an object with properties such as name, location, and properties.template. The example shows a template with experimental features enabled.

```json
{
  "name": "deploymentOutput",
  "location": "",
  "properties": {
    "template": {
      "contentVersion": "1.0.0.0",
      "metadata": {
        "_EXPERIMENTAL_WARNING": "This template uses ARM features that are experimental. Experimental features should be enabled for testing purposes only, as there are no guarantees about the quality or stability of these features. Do not enable these settings for any production usage, or your production environment may be subject to breaking.",
        "_EXPERIMENTAL_FEATURES_ENABLED": [
          "Asserts"
        ],
        "_generator": {
          "name": "bicep",
          "version": "0.39.26.7824",
          "templateHash": "10348958332696598785"
        }
      }
    }
  }
}

```

--------------------------------

### Bicep take function example

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/bicep-functions-array

Takes a specified number of elements from the start of an array and characters from the start of a string. With default values, arrayOutput is ["one", "two"] and stringOutput is "on".

```bicep
param testArray array = [
  'one'
  'two'
  'three'
]
param elementsToTake int = 2
param testString string = 'one two three'
param charactersToTake int = 2

output arrayOutput array = take(testArray, elementsToTake)
output stringOutput string = take(testString, charactersToTake)

```

--------------------------------

### tenantResourceId: Deploy policy assignment referencing built-in policy definition

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/bicep-functions-resource

Bicep example using tenantResourceId to reference a built-in policy definition in a policy assignment. The policyDefinitionID parameter defaults to a specific GUID, and the policyAssignmentName uses guid() for idempotency.

```bicep
@description('Specifies the ID of the policy definition or policy set definition being assigned.')
param policyDefinitionID string = '0a914e76-4921-4c19-b460-a2d36003525a'

@description('Specifies the name of the policy assignment, can be used defined or an idempotent name as the defaultValue provides.')
param policyAssignmentName string = guid(policyDefinitionID, resourceGroup().name)

resource policyAssignment 'Microsoft.Authorization/policyAssignments@2025-03-01' = {
  name: policyAssignmentName
  properties: {
    scope: subscriptionResourceId('Microsoft.Resources/resourceGroups', resourceGroup().name)
    policyDefinitionId: tenantResourceId('Microsoft.Authorization/policyDefinitions', policyDefinitionID)
  }
}
```

--------------------------------

### Deploy modules to multiple existing resource groups

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/modules

This example demonstrates deploying storage accounts to two different, pre-existing resource groups by referencing them via their symbolic names.

```Bicep
targetScope = 'subscription'

resource firstRG 'Microsoft.Resources/resourceGroups@2025-04-01' existing = {
  name: 'demogroup1'
}

resource secondRG 'Microsoft.Resources/resourceGroups@2025-04-01' existing = {
  name: 'demogroup2'
}

module storage1 '../create-storage-account/main.bicep' = {
  name: 'westusdeploy'
  scope: firstRG
  params: {
    storagePrefix: 'stg1'
    location: 'westus'
  }
}

module storage2 '../create-storage-account/main.bicep' = {
  name: 'eastusdeploy'
  scope: secondRG
  params: {
    storagePrefix: 'stg2'
    location: 'eastus'
  }
}
```

--------------------------------

### Sample output of deployer()

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/bicep-functions-deployment

Sample output of the deployer() function. Values differ based on your deployment.

```json
{
  "objectId":"aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb",
  "tenantId":"aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e",
  "userPrincipalName":"john.doe@contoso.com"
}
```

--------------------------------

### Module without name property

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/modules

Omitting the name property is valid; a GUID is generated as the module name. This example also sets the scope to a different resource group.

```bicep
module stgModule 'storageAccount.bicep' = {
  scope: resourceGroup('demoRG')
}

```

--------------------------------

### Bicep for loop over array of objects

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/quickstart-loops

Loops through an array of objects to create storage accounts, customizing both names and SKUs. The storage account with name starting with 'fabrikam' gets Premium_LRS.

```Bicep
param rgLocation string = resourceGroup().location
param storages array = [
  {
    name: 'contoso'
    skuName: 'Standard_LRS'
  }
  {
    name: 'fabrikam'
    skuName: 'Premium_LRS'
  }
]

resource createStorages 'Microsoft.Storage/storageAccounts@2025-06-01' = [for storage in storages: {
  name: '${storage.name}obj${uniqueString(resourceGroup().id)}'
  location: rgLocation
  sku: {
    name: storage.skuName
  }
  kind: 'StorageV2'
}]

```

--------------------------------

### Deploy to the tenant using tenant()

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/deploy-to-management-group

Uses a module with the tenant() function to target the tenant. The user must have the required access to deploy at the tenant.

```Bicep
targetScope = 'managementGroup'

// module deployed at tenant level
module exampleModule 'module.bicep' = {
  name: 'deployToTenant'
  scope: tenant()
}

```

--------------------------------

### Extract parts of a string using split

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/diagnostics/bcp076

If you need to extract parts of a string, use string functions like split or substring. This example uses split to get an array of characters.

```bicep
var text = 'hello'
var chars = split(text, '') // Returns ['h', 'e', 'l', 'l', 'o']
var firstChar = chars[0] // Returns 'h'

```

--------------------------------

### Example with non-existent public module version

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/diagnostics/bcp192

This example raises the BCP192 diagnostic because the public module version '0.1.0' does not exist for the AVM storage account module.

```bicep
module storage 'br/public:avm/res/storage/storage-account:0.1.0' = {
  name: 'myStorage'
  params: {
    name: 'store${resourceGroup().name}'
  }
}

```

--------------------------------

### Check Bicep version with Azure CLI

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/bicep-cli

Returns the installed Bicep version through the Azure CLI. The output shows the version number, for example: Bicep CLI version 0.29.45 (57a44c0230).

```bash
az bicep version

```

```console
Bicep CLI version 0.29.45 (57a44c0230)

```

--------------------------------

### Bicep file parameters example (main.bicep)

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/parameter-files

Shows the parameters section of a Bicep file named main.bicep, including a maxLength constraint and an allowed values list.

```bicep
@maxLength(11)
param storagePrefix string

@allowed([
  'Standard_LRS'
  'Standard_GRS'
  'Standard_ZRS'
  'Premium_LRS'
])
param storageAccountType string = 'Standard_LRS'

```

--------------------------------

### Install Bicep MCP server with dnx

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/bicep-mcp-server

Uses .NET 10.0 SDK's dnx to get the latest version of the Bicep MCP server directly from the NuGet package without building it yourself.

```bash
dnx -y Azure.Bicep.McpServer

```

--------------------------------

### first function example with array and string

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/bicep-functions-array

Shows how to use the first function with an array and a string. The array parameter defaults to ['one', 'two', 'three'], and the outputs are 'one' and 'O' respectively.

```bicep
param arrayToTest array = [
  'one'
  'two'
  'three'
]

output arrayOutput string = first(arrayToTest)
output stringOutput string = first('One Two Three')

```

--------------------------------

### JSON output example for deployment script

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/deployment-script-bicep

Example JSON output from a deployment script resource, showing properties like provisioningState, scriptContent, outputs, and cleanupPreference.

```json
{
  "kind": "AzureCLI",
  "identity": null,
  "location": "centralus",
  "systemData": {
    "createdAt": "2023-12-11T19:45:32.239063+00:00",
    "createdBy": "johndole@contoso.com",
    "createdByType": "User",
    "lastModifiedAt": "2023-12-11T20:18:26.183565+00:00",
    "lastModifiedBy": "johndole@contoso.com",
    "lastModifiedByType": "User"
  },
  "properties": {
    "provisioningState": "Succeeded",
    "azCliVersion": "2.89.1",
    "scriptContent": "echo \"The argument is John Dole.\"; jq -n -c --arg st \"Hello John Dole\" '{\"text\": $st}' > $AZ_SCRIPTS_OUTPUT_PATH",
    "arguments": "John Dole",
    "retentionInterval": "1:00:00",
    "timeout": "1 day, 0:00:00",
    "containerSettings": {
      "containerGroupName": null
    },
    "status": {
      "containerInstanceId": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/dsDemo/providers/Microsoft.ContainerInstance/containerGroups/jgczqtxom5oreazscripts",
      "endTime": "2023-12-11T20:20:12.149468+00:00",
      "error": null,
      "expirationTime": "2023-12-11T21:20:12.149468+00:00",
      "startTime": "2023-12-11T20:18:26.674492+00:00",
      "storageAccountId": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/dsDemo/providers/Microsoft.Storage/storageAccounts/jgczqtxom5oreazscripts"
    },
    "outputs": {
      "text": "Hello John Dole"
    },
    "cleanupPreference": "OnSuccess"
  },
  "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/dsDemo/providers/Microsoft.Resources/deploymentScripts/inlineCLI",
  "type": "Microsoft.Resources/deploymentScripts",
  "name": "inlineCLI"
}
```

--------------------------------

### Index accessor: get element from array

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/operators-access

Uses the index accessor with an integer index to retrieve an element from an array. The index is zero-based. The example defines an array and outputs the element at index 1, which is 'Contoso'.

```bicep
var arrayVar = [
  'Coho'
  'Contoso'
  'Fabrikam'
]

output accessorResult string = arrayVar[1]

```

--------------------------------

### Passing example: outputs with parameters or expressions

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/linter-rule-no-hardcoded-outputs

This example passes the rule because the outputs reference parameters, use string interpolation with a parameter, or call functions. It shows acceptable output patterns.

```bicep
param name string

output reference string = name
output interpolated string = 'literal-${name}'
output functionResult string = toLower('LITERAL')
output arrayWithExpression array = [
  'literal'
  name
]
output objectWithExpression object = {
  literal: 'literal'
  reference: name
}

```

--------------------------------

### Bicep length function in conditional expression for availability zones

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/bicep-functions-array

Extracted from a quickstart template, this example uses `length` to check if the `availabilityZones` array is empty and conditionally sets the `zones` property to null or the array.

```bicep
@description('Numbers for availability zones, for example, 1,2,3.')
param availabilityZones array = [
  '1'
  '2'
]

resource exampleApim 'Microsoft.ApiManagement/service@2024-10-01-preview' = {
  name: apiManagementName
  location: location
  sku: {
    name: sku
    capacity: skuCount
  }
  zones: ((length(availabilityZones) == 0) ? null : availabilityZones)
  ...
}

```

--------------------------------

### Create resource group with Azure CLI

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/deploy-github-actions

Use this command to create a resource group named 'exampleRG' in the 'westus' location. This resource group will be used later when deploying your Bicep file.

```bash
az group create -n exampleRG -l westus

```

--------------------------------

### Get physical zone for a logical zone in West US 2

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/bicep-functions-resource

This example retrieves the physical zone for a logical zone in West US 2 for a specific subscription. The output is the physical zone identifier, such as 'westus2-az1'.

```bicep
param subscriptionId string = '12345678-1234-1234-1234-1234567890ab'
param logicalZone string = '1'

output physicalZone string = toPhysicalZone(subscriptionId, 'westus2', logicalZone)

```

--------------------------------

### Deploy with JSON parameters file (Azure CLI)

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/deploy-cli

Use a .parameters.json file with the --parameters switch, prefixed with @. The file must be local. The example shows deploying with a JSON parameters file.

```bash
az deployment group create \
  --name ExampleDeployment \
  --resource-group ExampleGroup \
  --template-file storage.bicep \
  --parameters '@storage.parameters.json'

```

--------------------------------

### Bicep example using subscriptionResourceId to assign a built-in role

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/bicep-functions-resource

This Bicep file assigns a built-in role and can be deployed to either a resource group or subscription. It uses the subscriptionResourceId function to get the resource ID for built-in roles.

```bicep
@description('Principal Id')
param principalId string

@allowed([
  'Owner'
  'Contributor'
  'Reader'
])
@description('Built-in role to assign')
param builtInRoleType string

var roleDefinitionId = {
  Owner: {
    id: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', '8e3af657-a8ff-443c-a75c-2fe8c4bcb635')
  }
  Contributor: {
    id: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'b24988ac-6180-42a0-ab88-20f7382dd24c')
  }
  Reader: {
    id: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'acdd72a7-3385-48ef-bd42-f606fba81ae7')
  }
}

resource roleAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, principalId, roleDefinitionId[builtInRoleType].id)
  properties: {
    roleDefinitionId: roleDefinitionId[builtInRoleType].id
    principalId: principalId
  }
}
```

--------------------------------

### Index accessor: get property from object

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/operators-access

Uses the index accessor with a string index to retrieve a property from an object. The example defines an object with 'dev' and 'prod' properties, then accesses the 'dev' property's 'name' value, which is 'Development'.

```bicep
var environmentSettings = {
  dev: {
    name: 'Development'
  }
  prod: {
    name: 'Production'
  }
}

output accessorResult string = environmentSettings['dev'].name

```

--------------------------------

### Examples of defining and using user-defined functions

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/user-defined-functions

Shows multiple user-defined functions and their usage in outputs. The functions demonstrate string, object, and array return types, and the outputs show how to call them.

```bicep
func buildUrl(https bool, hostname string, path string) string => '${https ? 'https' : 'http'}://${hostname}${empty(path) ? '' : '/${path}'}'

func sayHelloString(name string) string => 'Hi ${name}!'

func sayHelloObject(name string) object => {
  hello: 'Hi ${name}!'
}

func nameArray(name string) array => [
  name
]

func addNameArray(name string) array => [
  'Mary'
  'Bob'
  name
]

output azureUrl string = buildUrl(true, 'microsoft.com', 'azure')
output greetingArray array = map(['Evie', 'Casper'], name => sayHelloString(name))
output greetingObject object = sayHelloObject('John')
output nameArray array = nameArray('John')
output addNameArray array = addNameArray('John')

```

--------------------------------

### Assign user-assigned managed identity to a Bicep module

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/modules

Starting with Bicep version 0.36.1, you can assign a user-assigned managed identity to a module. The identity is available within the module, for example to access a Key Vault, but backend services don't yet support this capability.

```bicep
param identityId string

module mod './module.bicep' = {
  identity: {
    type: 'UserAssigned'
    userAssignedIdentities: {
      '${identityId}': {}
    }
  }
  name: 'mod'
  params: {
    keyVaultUri: 'keyVaultUri'
    identityId: identityId
  }
}

```

--------------------------------

### Deploy local Bicep file with parameters

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/deploy-cli

Deploys a local Bicep file using the --template-file switch and sets a parameter value. The deployment can take a few minutes to complete.

```bash
az deployment group create \
  --name ExampleDeployment \
  --resource-group ExampleGroup \
  --template-file <path-to-bicep> \
  --parameters storageAccountType=Standard_GRS

```

--------------------------------

### Deploy storage account and web app module in Bicep

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/file

Demonstrates the implementation of Bicep elements including metadata, decorated parameters, variables, a resource declaration, and a module deployment.

```bicep
metadata description = 'Creates a storage account and a web app'

@description('The prefix to use for the storage account name.')
@minLength(3)
@maxLength(11)
param storagePrefix string

param storageSKU string = 'Standard_LRS'
param location string = resourceGroup().location

var uniqueStorageName = '${storagePrefix}${uniqueString(resourceGroup().id)}'

resource stg 'Microsoft.Storage/storageAccounts@2025-06-01' = {
  name: uniqueStorageName
  location: location
  sku: {
    name: storageSKU
  }
  kind: 'StorageV2'
  properties: {
    supportsHttpsTrafficOnly: true
  }
}

module webModule './webApp.bicep' = {
  name: 'webDeploy'
  params: {
    skuName: 'S1'
    location: location
  }
}

```

--------------------------------

### Return GUIDs for subscription, resource group, and deployment

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/bicep-functions-string

Outputs GUIDs for each scope using the guid function.

```bicep
output guidPerSubscription string = guid(subscription().subscriptionId)
output guidPerResourceGroup string = guid(resourceGroup().id)
output guidPerDeployment string = guid(resourceGroup().id, deployment().name)

```

--------------------------------

### az bicep install

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/bicep-cli

Installs the Bicep CLI to your local environment. Only available through Azure CLI. Can install the latest version or a specific version.

```APIDOC
## az bicep install

### Description
Adds the Bicep CLI to your local environment. Only available through the Azure CLI.

### Method
Azure CLI command

### Endpoint
`az bicep install`

### Parameters
#### Optional Parameters
- **--version** (string) - Optional - Version of Bicep CLI to install. If not specified, installs the latest version.

### Request Example
```
az bicep install
```

### Response
#### Success Response
Installs the Bicep CLI. No response body.

#### Response Example
No response body.
```

--------------------------------

### Use like to match string patterns

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/bicep-functions-string

Shows how to use the `like` function to check a string against patterns with wildcards. The example defines a resource name variable and outputs boolean results for various patterns. The output is: containsProd = true, startsWithProd = true, endsWith01 = true, exactMatch = true, noMatch = false.

```bicep
var resourceName = 'prod-eastus-vm01'

output containsProd bool = like(resourceName, '*prod*')
output startsWithProd bool = like(resourceName, 'prod*')
output endsWith01 bool = like(resourceName, '*01')
output exactMatch bool = like(resourceName, 'prod-eastus-vm01')
output noMatch bool = like(resourceName, '*westus*')

```

--------------------------------

### Prompt to get a deployment snapshot

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/quickstart-create-bicep-use-visual-studio-code-model-context-protocol

Submit this prompt to get a snapshot of the deployment. The "Ran Get deployment snapshot" command runs.

```text
Get a snapshot of the deployment.

```

--------------------------------

### Deploy with Bicep parameters file (Azure CLI)

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/deploy-cli

Use a .bicepparam file with the --parameters switch. The using statement in the file eliminates the need for --template-file. Including --template-file will cause an error. Requires Azure CLI 2.53.0+ and Bicep CLI 0.22.X+.

```bash
az deployment group create \
  --name ExampleDeployment \
  --resource-group ExampleGroup \
  --parameters storage.bicepparam

```

--------------------------------

### Install Bicep language server globally with dotnet tool install

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/install

Installs the Azure.Bicep.LangServer .NET global tool, making the bicep-ls command available on your PATH.

```bash
dotnet tool install --global Azure.Bicep.LangServer

```

--------------------------------

### bicep/compile result example

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/bicep-cli-jsonrpc

Example result for bicep/compile, showing success, diagnostics, and contents.

```JSON
{
  "success": true,
  "diagnostics": [],
  "contents": "{\"$schema\": \"https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#\", ...}"
}
```

--------------------------------

### Create main.bicepparam file

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/msbuild-bicep-file

Bicep parameters file that references the main.bicep file and defines a prefix parameter.

```bicep
using './main.bicep'

param prefix = '{prefix}'

```

--------------------------------

### Fixed example: VM with stable image

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/linter-rule-use-stable-vm-image

This Bicep example passes the 'use-stable-vm-image' rule by using an image that doesn't contain 'preview' in the imageReference.

```bicep
param location string = resourceGroup().location

resource vm 'Microsoft.Compute/virtualMachines@2025-04-01' = {
  name: 'virtualMachineName'
  location: location
  properties: {
    storageProfile: {
      imageReference: {
        offer: 'WindowsServer'
        sku: '2019-Datacenter'
        version: 'latest'
      }
    }
  }
}

```

--------------------------------

### Fixed example: turning the variable into a parameter

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/linter-rule-no-loc-expr-outside-params

This example fixes the failure by turning the variable into a parameter.

```bicep
  param location string  = resourceGroup().location

```

--------------------------------

### Bicep example: storage account, file service, and file share at root level

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/child-resource-name-type

Concrete example defining a storage account, its file service, and a file share all at the root level. The file service uses parent: storage, and the share uses parent: service. The type includes slashes to include the parent type and name.

```bicep
resource storage 'Microsoft.Storage/storageAccounts@2025-06-01' = {
  name: 'examplestorage'
  location: resourceGroup().location
  kind: 'StorageV2'
  sku: {
    name: 'Standard_LRS'
  }
}

resource service 'Microsoft.Storage/storageAccounts/fileServices@2025-06-01' = {
  name: 'default'
  parent: storage
}

resource share 'Microsoft.Storage/storageAccounts/fileServices/shares@2025-06-01' = {
  name: 'exampleshare'
  parent: service
}

```

--------------------------------

### Failing example using reference and listKeys functions

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/linter-rule-use-resource-symbol-reference

This Bicep example fails the `use-resource-symbol-reference` linter rule because it uses `reference(storageAccount.id, '2023-05-01')` and `listKeys(storageAccount.id, '2023-05-01')` to access storage account properties. The example creates an HDInsight cluster with a storage profile that references an existing storage account.

```bicep
@description('The name of the HDInsight cluster to create.')
param clusterName string

@description('These credentials can be used to submit jobs to the cluster and to log into cluster dashboards.')
param clusterLoginUserName string

@description('The password must be at least 10 characters in length and must contain at least one digit, one uppercase letter, one lowercase letter, and one non-alphanumeric character (except single-quote, double-quote, backslash, right-bracket, or full-stop characters). Also, the password must not contain three consecutive characters from the cluster username or SSH username.')
@minLength(10)
@secure()
param clusterLoginPassword string

@description('Location for all resources.')
param location string = resourceGroup().location

param storageAccountName string = uniqueString(resourceGroup().id)

resource storageAccount 'Microsoft.Storage/storageAccounts@2025-06-01' existing = {
  name: storageAccountName
}

resource cluster 'Microsoft.HDInsight/clusters@2025-01-15-preview' = {
  name: clusterName
  location: location
  properties: {
    clusterVersion: '4.0'
    osType: 'Linux'
    clusterDefinition: {
      kind: 'hbase'
      configurations: {
        gateway: {
          'restAuthCredential.isEnabled': true
          'restAuthCredential.username': clusterLoginUserName
          'restAuthCredential.password': clusterLoginPassword
        }
      }
    }
    storageProfile: {
      storageaccounts: [
        {
          name: replace(replace(reference(storageAccount.id, '2023-05-01').primaryEndpoints.blob, 'https://', ''), '/', '')
          isDefault: true
          container: clusterName
          key: listKeys(storageAccount.id, '2023-05-01').keys[0].value
        }
      ]
    }
  }
}

```

--------------------------------

### bicep/compileParams params example

Source: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/bicep-cli-jsonrpc

Example params for bicep/compileParams, specifying the path and an empty parameterOverrides object.

```JSON
{
  "path": "/path/to/main.bicepparam",
  "parameterOverrides": {}
}
```
Tokens:
Raw