Best practices dilemma: explicit dependencies and cleaner code or implicit dependencies with less cleaner code

[ghost]

I'm writing bicep code to deploy multiple resources with a single module file by using loops. The goal is to having one bicep solution for this (static environment). Following best practices I should avoid using explicit dependencies.

PARAMETER FILE
===========
using './main.bicep'

param location = 'westeurope'

// Groups
param groups = [
  'testtest-rg-test1'
  'testtest-rg-test2'
]

param publicips = [
  'testtest-pip-test1'
  'testtest-pip-test2'
]

OPTION A - implicit dependencies, The scope declaration is really ugly to be honest...

MAIN.BICEP
========
targetScope = 'subscription'

@allowed(['westeurope'])
param location string

// Groups
param groups array 
param publicips array

module mod_rg './modules/resource-group.bicep' = [ for group in groups: {
  name: group
  scope: subscription()
    params: {
      name: group
      location: location
    }
}]

module mod_pip './modules/public-ip.bicep' = [ for publicip in publicips: {
  name: publicip
  scope: resourceGroup(mod_rg[indexOf(groups, first(filter(groups, x => x == 'testtest-rg-test1')))].name)
  params: {
    location: location
    publicip: publicip
  }
}]

OPTION B - explicit dependencies, a lot cleaner but 'what-if' doesn't detect the publicips...

targetScope = 'subscription'

@allowed(['westeurope'])
param location string

// Groups
param groups array 
param publicips array

module mod_rg './modules/resource-group.bicep' = [ for group in groups: {
  name: group
  scope: subscription()
    params: {
      name: group
      location: location
    }
}]

module mod_pip './modules/public-ip.bicep' = [ for publicip in publicips: {
  name: publicip
  dependsOn: [mod_rg]
  scope: resourceGroup('testtest-rg-test-1')
  params: {
    location: location
    publicip: publicip
  }
}]

Which one should I use?

[johnlokerse]

Hi @nelo-0,

I have a suggestion for a different, and maybe a better or more readable approach. The options you are giving are okay too, but I foresee readability issues. I would go for a KISS approach. This is what I would suggest for you:

Environment.bicep
This Bicep represents your environment and contain references to your resources or modules that you need for each environment.

targetScope = 'subscription'

@allowed([
  'dev'
  'qa'
  'prod'
])
param parEnvironment string = 'dev'

param parResourceGroupName string
param parPublicIpName string

resource resResourceGroup 'Microsoft.Resources/resourceGroups@2023-07-01' = {
  name: parResourceGroupName
  location: 'westeurope'
}

module modPublicIp 'publicIp.bicep' = {
  name: 'deploy-pip-${parEnvironment}'
  scope: resourceGroup(resResourceGroup.name)
  params: {
    parPublicIpName: parPublicIpName
    // other module properties here
  }
}

// append more modules needed for your environment

Main.bicep
Here you reference the module Environment.bicep. In the main bicep you create an parEnvironment parameter which holds an array of objects. These objects contain configuration for each of the environment (for example dev, qa and prod). Also, this fixes the issue of complex scope definitions and you avoid explicit dependencies.

targetScope = 'subscription'

type environmentType = {
  environmentType: ('dev' | 'qa' | 'prod')
  resourceGroupName: string
  publicIpName: string

  *: string
}[]

param parEnvironments environmentType = [
  {
    environmentType: 'dev'
    resourceGroupName: 'rg-dev'
    publicIpName: 'pip-dev'
    // append other properties here
  }
  {
    environmentType: 'qa'
    resourceGroupName: 'rg-qa'
    publicIpName: 'pip-qa'
    // append other properties here
  }
  {
    environmentType: 'qa'
    resourceGroupName: 'rg-prod'
    publicIpName: 'pip-prod'
    // append other properties here
  }
]

module modEnvironments 'environment.bicep' = [for environment in parEnvironments: {
  name: 'deploy-environment-${environment.environmentType}'
  params: {
    parResourceGroupName: environment.resourceGroupName
    parEnvironment: environment.environmentType
    parPublicIpName: environment.publicIpName
  }
}]

This is what I would suggest. Simple, maintainable and scalable. Let me know if you have more questions. 💪