User defined function for naming conventions

[calindtech]

I would like to create a userdefined-function for get consistent naming convetions.
Now it is a bit clunky, but could be much easier if i could access the variables in the result object or if you could have a function body separate from result.

Here is my try so far, but its not pretty :

@description('')
@export()
var resourceTypesAbbreviations = {
  ApplicationGateway: 'appGateway-'
  AvailabilitySet: 'as-'
  ContainerService: 'acs-'
  ContainerRegistry: 'acr-'
  ContainerGroup: 'acg-'
  ContainerInstance: 'aci-'
  CosmosDB: 'cosmosdb-'
  DataLakeAnalytics: 'adla-'
  DataLakeStore: 'adls-'
  DataFactory: 'adf-'
  DataFactoryV2: 'adf-'
  Disk: 'disk-'
  LoadBalancer: 'lb-'
  NetworkInterface: 'nic-'
  NetworkSecurityGroup: 'nsg-'
  PublicIPAddress: 'pip-'
  VirtualMachine: 'vm-'
  VirtualNetworkGateway: 'vng-'
  VirtualMachineScaleSet: 'vmss-'
  VirtualNetwork: 'vnet-'
  Subnet: 'subnet-'
  RouteTable: 'rt-'
  StorageAccount: 'storage-'
  TrafficManager: 'tm-'
  KeyVault: 'kv-'
  RedisCache: 'redis-'
  ApplicationInsights: 'appInsights-'
  ServiceBus: 'sb-'
  EventHub: 'eh-'
  EventGrid: 'eg-'
  NotificationHub: 'nh-'
  IoTEventHub: 'iothub-'
  IoTEventHubConsumerGroup: 'iothub-'

}

type namingPartsType = {
  functionShort: string
  functionName: string
  teamName: string
  environment: string
  teamNameShort: string
  environmentLetter: string
  varIndex: string
  resourceAbbrevation: string
  result: namingType
}
type namingType = {
  resourceName: string
  resourceNameShort: string
  storageAccountName: string
  vmName: string
}


// User-defined function to generate resource names
func generateResourceNameParts(resourceAbbrevation string,teamName string, functionName string, environment string, index int, locationShort string) namingPartsType => {
  functionShort: length(functionName) > 5 ? substring(functionName, 0, 5) : functionName
  functionName: functionName
  teamName: teamName
  environment: environment
  teamNameShort: length(teamName) > 5 ? substring(teamName, 0, 5) : teamName
  environmentLetter: substring(environment, 0, 1)
  varIndex: index == 0 ? '' : padLeft(index, 2, '0')
  resourceAbbrevation: resourceAbbrevation
  result: generateResourceNames(resourceAbbrevation,teamName, length(teamName) > 5 ? substring(teamName, 0, 5) : teamName, functionName, length(functionName) > 5 ? substring(functionName, 0, 5) : functionName, environment, substring(environment, 0, 1), index == 0 ? '' : padLeft(index, 2, '0'), locationShort)
}

func generateResourceNames(resourceAbbrevation string,teamName string, teamNameShort string, functionName string, functionShort string, environment string, environmentLetter string, varIndex string, locationShort string) object => {
  resourceName: '${resourceAbbrevation}-${teamNameShort}-${functionShort}-${environmentLetter}${varIndex}-${locationShort}'
  resourceNameShort: '${resourceAbbrevation}-${teamNameShort}-${functionShort}-${environmentLetter}${varIndex}'
  storageAccountName: '${resourceAbbrevation}-${teamNameShort}${functionShort}${environmentLetter}${varIndex}${locationShort}'
  vmName: '${resourceAbbrevation}-${teamNameShort}-${functionShort}-${environmentLetter}${varIndex}-${locationShort}'
}
// Usage
var resourceNames = generateResourceNameParts( resourceTypesAbbreviations.ApplicationGateway, 'teamName', 'function', 'environment', 0, 'weu')

output resourceName string = resourceNames.result.resourceName
output resourceNameShort string = resourceNames.result.resourceNameShort
output storageAccountName string = resourceNames.result.storageAccountName
output vmName string = resourceNames.result.vmName

[ahelland]

I could see why a user-defined function is tempting, but as you say it can look a little clunky and it can be solved in other ways as well. Depends how complicated you want to do it, but at the simplest end of the scale you can add the prefixes to a separate json file:

{
    "resourceGroup": "rg-",
    "applicationGateway": "agw-",
    "containerRegistry": "acr"
}

Add something like this to your main.bicep:
var prefix = loadJsonContent('prefixes.json')

And combine it with a unique string for resources that can have name collisions:

module acr 'br/Modules:containers/container-registry:v1.00' = {
  scope: rg_acr
  name: '${prefix.containerRegistry}-${env}'
  params: {
    resourceTags: resourceTags
    acrName: toLower('${prefix.containerRegistry}${uniqueString(subscription().id, rg_acr.id)}')
...
}

On the other end of the scale you have the Azure Naming Tool:
https://github.com/mspnp/AzureNamingTool

That way you can do name generation as part of the build pipelines and what-not.

[calindtech]

@ahelland
Thanks for the suggestions i also could add another neat solution:
Get a consistent Azure naming convention with Bicep modules

I just think with a little support of function body and scoped variables in the user-defined functions we could do something really nice 😄

[ahelland]

User-defined functions are a useful addition to the tool belt, so I agree nice things can be done that way. It depends on the scale of things though - my experience is that once you get down to creating a bunch of resources the name standard is just part of what you use for wrangling the resources.

The more interesting piece longer term is how the Azure Verified Modules play out - those will need an opinion on naming.

[anthony-c-martin]

One thing to mention about using modules for utility functionality like generating names is that (a) they will add time to your deployment which adds up quickly if they're used heavily, and (b) they will show up as legitimate deployments in the UI, which can make it harder to analyze a historical deployment.

I'm keen on hearing about the gaps with user-defined functions - I would like to encourage their usage instead of modules in the long run for utility functionality, but understand we're not in a place to do that just yet.

[ChristopherGLewis]

I've been mucking with this for the above naming standard issue and also tagging. What I have for tagging is something like this:

"module" - in quotes because its a module only kindof - more of an import

// ------------------------------------------------------------------
// Tagging import -
// ------------------------------------------------------------------
@export()
type envAllowedKeys = 'prd' | 'stg' | 'lab'

@export()
type productAllowedKeys = 'shared' |   'networking' |   'application1' |'application2'

@export()
type costOwnerAllowedKeys = 'infra' | 'dba' | 'appteam1'| 'appteam2'

@export()
type costTypeAllowedKeys = 'other' | 'storage' | 'compute' | 'networking' |'monitoring' | 'data'

@export()
func tagFunction(environmentKey envAllowedKeys, productKey productAllowedKeys, costOwnerKey costOwnerAllowedKeys, costTypeKey costTypeAllowedKeys) object => {
  env:  environmentKey
  owner:  productKey
  product:  costOwnerKey
  type:  costTypeKey
}

usage

targetScope = 'subscription'

// ------------------------------------------------------------
// Tagging import - call at top level deploy, once per deployment
// ------------------------------------------------------------
//Import Tagging Types
import * as taggingTypes from '../modules/import.taggingfunction-v1.bicep'

param envKey taggingTypes.envAllowedKeys = 'stg'
param prodKey taggingTypes.productAllowedKeys = 'shared'
param ownerKey taggingTypes.costOwnerAllowedKeys = 'infra'
param typeKey taggingTypes.costTypeAllowedKeys = 'net'

var stdTags = taggingTypes.tagFunction(envKey, prodKey, ownerKey,typeKey)
// ------------------------------------------------------------

param rgName string = 'hub-eus-vnet-rg'

resource rg 'Microsoft.Resources/resourceGroups@2023-07-01'  = {
  name: rgName
  location: 'eastus'
  tags: stdTags
}

This construct should also work for naming standards, albeit with a much more complicated function.

Any ETA on functions being not preview?

[anthony-c-martin]

#12911 is the only issue I'm aware of that necessitates the experimental feature flag. Unfortunately I haven't had the time to fix it properly - I might see if I can just block it for now to unblock the release.

[verschaevesiebe]

Hi @calindtech,

You absolute legend !
I was trying to build something together with some colleagues but this is a head start.
Since your post, the user defined functions are GA but still no support for any valid "if" statements or operational functionalities lets say.

I'm hoping for this in the future to be honest.
Naming functions should be something default as it's heavily used and provides consistency.