Tipos de dados definidos pelo usuário no Bicep

Saiba como criar tipos de dados definidos pelo usuário no Bicep. Para tipos de dados definidos pelo sistema, consulte Tipos de dados.

A CLI do Bicep versão 0.12.X ou superior é necessária para usar esse recurso.

Sintaxe

Você pode usar a type instrução para criar tipos de dados definidos pelo usuário. Além disso, você também pode usar expressões de texto em alguns lugares para definir tipos personalizados.

type <user-defined-data-type-name> = <type-expression>

O @allowed decorador só é permitido em param declarações. Para declarar um tipo com um conjunto de valores predefinidos em um type, use a sintaxe de tipo união.

As expressões de tipo válidas incluem:

• Referências simbólicas são identificadores que se referem a um tipo de ambiente (como string ou int) ou um símbolo de tipo definido pelo usuário declarado em uma type instrução:

  // Bicep data type reference
  type myStringType = string
  
  // user-defined type reference
  type myOtherStringType = myStringType
  

• Literais primitivos, incluindo strings, inteiros e booleanos, são expressões de tipo válidas. Por exemplo:

  // a string type with three allowed values.
  type myStringLiteralType = 'bicep' | 'arm' | 'azure'
  
  // an integer type with one allowed value
  type myIntLiteralType = 10
  
  // an boolean type with one allowed value
  type myBoolLiteralType = true
  

• Você pode declarar tipos de matriz anexando a qualquer expressão de [] tipo válida:

  // A string type array
  type myStrStringsType1 = string[]
  // A string type array with three allowed values
  type myStrStringsType2 = ('a' | 'b' | 'c')[]
  
  type myIntArrayOfArraysType = int[][]
  
  // A mixed-type array with four allowed values
  type myMixedTypeArrayType = ('fizz' | 42 | {an: 'object'} | null)[]
  

• Os tipos de objeto contêm zero ou mais propriedades entre colchetes:

  type storageAccountConfigType = {
    name: string
    sku: string
  }
  

  Cada propriedade em um objeto consiste em uma chave e um valor, separados por dois pontos :. A chave pode ser qualquer cadeia de caracteres, com valores não identificadores entre aspas, e o valor pode ser qualquer tipo de expressão.

  As propriedades são necessárias, a menos que tenham um marcador ? de opcionalidade após o valor da propriedade. Por exemplo, a sku propriedade no exemplo a seguir é opcional:

  type storageAccountConfigType = {
    name: string
    sku: string?
  }
  

  Os decoradores podem ser usados em propriedades. * pode ser usado para fazer com que todos os valores exijam uma restrição. Propriedades adicionais ainda podem ser definidas ao usar *o . Este exemplo cria um objeto que requer uma chave do tipo int chamada id e que todas as outras entradas no objeto devem ter um valor de cadeia de caracteres com pelo menos 10 caracteres.

  type obj = {
    @description('The object ID')
    id: int
  
    @description('Additional properties')
    @minLength(10)
    *: string
  }
  

  O exemplo a seguir mostra como usar a sintaxe de tipo união para listar um conjunto de valores predefinidos:

  type directions = 'east' | 'south' | 'west' | 'north'
  
  type obj = {
    level: 'bronze' | 'silver' | 'gold'
  }
  

  Recursão

  Os tipos de objeto podem usar recursão direta ou indireta, desde que pelo menos a perna do caminho até o ponto de recursão seja opcional. Por exemplo, a myObjectType definição no exemplo a seguir é válida porque a propriedade diretamente recursiva recursiveProp é opcional:

  type myObjectType = {
    stringProp: string
    recursiveProp: myObjectType?
  }
  

  Mas a seguinte definição de tipo não seria válida porque nenhum dos level1, level2, level3, level4, ou level5 é opcional.

  type invalidRecursiveObjectType = {
    level1: {
      level2: {
        level3: {
          level4: {
            level5: invalidRecursiveObjectType
          }
        }
      }
    }
  }
  

• Os operadores unários bíceps podem ser usados com literais inteiros e booleanos ou referências a símbolos inteiros ou booleanos digitados literalmente:

  type negativeIntLiteral = -10
  type negatedIntReference = -negativeIntLiteral
  
  type negatedBoolLiteral = !true
  type negatedBoolReference = !negatedBoolLiteral
  

• As uniões podem incluir qualquer número de expressões digitadas literalmente. Os tipos de união são traduzidos na restrição de valor permitido no Bicep, portanto, apenas literais são permitidos como membros.

  type oneOfSeveralObjects = {foo: 'bar'} | {fizz: 'buzz'} | {snap: 'crackle'}
  type mixedTypeArray = ('fizz' | 42 | {an: 'object'} | null)[]
  

Além de serem usadas na instrução, expressões type de tipo também podem ser usadas nestes locais para criar tipos de dados definidos pelo usuário:

• Como a cláusula de tipo de uma param instrução. Por exemplo:

  param storageAccountConfig {
    name: string
    sku: string
  }
  

• Seguindo a : propriedade in an object type. Por exemplo:

  param storageAccountConfig {
   name: string
    properties: {
      sku: string
    }
  } = {
    name: 'store$(uniqueString(resourceGroup().id)))'
    properties: {
      sku: 'Standard_LRS'
    }
  }
  

• Precedendo o [] em uma expressão de tipo de matriz. Por exemplo:

  param mixedTypeArray ('fizz' | 42 | {an: 'object'} | null)[]
  

Um arquivo Bicep típico para criar uma conta de armazenamento se parece com:

param location string = resourceGroup().location
param storageAccountName string

@allowed([
  'Standard_LRS'
  'Standard_GRS'
])
param storageAccountSKU string = 'Standard_LRS'

resource storageAccount 'Microsoft.Storage/storageAccounts@2023-04-01' = {
  name: storageAccountName
  location: location
  sku: {
    name: storageAccountSKU
  }
  kind: 'StorageV2'
}

Usando tipos de dados definidos pelo usuário, ele pode se parecer com:

param location string = resourceGroup().location

type storageAccountSkuType = 'Standard_LRS' | 'Standard_GRS'

type storageAccountConfigType = {
  name: string
  sku: storageAccountSkuType
}

param storageAccountConfig storageAccountConfigType

resource storageAccount 'Microsoft.Storage/storageAccounts@2023-04-01' = {
  name: storageAccountConfig.name
  location: location
  sku: {
    name: storageAccountConfig.sku
  }
  kind: 'StorageV2'
}

Elevar o nível de erro

Por padrão, declarar um tipo de objeto no Bicep permite que ele aceite propriedades adicionais de qualquer tipo. Por exemplo, o seguinte Bicep é válido, mas gera um aviso de [BCP089] - The property "otionalProperty" is not allowed on objects of type "{ property: string, optionalProperty: null | string }". Did you mean "optionalProperty"?:

type anObject = {
  property: string
  optionalProperty: string?
}
 
param aParameter anObject = {
  property: 'value'
  otionalProperty: 'value'
}

O aviso informa que o tipo anObject não inclui uma propriedade chamada otionalProperty. Embora nenhum erro ocorra durante a implantação, o compilador Bicep assume que otionalProperty é um erro de digitação, que você pretendia usar optionalProperty mas digitou incorretamente, e alertá-lo para a inconsistência.

Para escalar esses avisos para erros, aplique o @sealed() decorador ao tipo de objeto:

@sealed() 
type anObject = {
  property: string
  optionalProperty?: string
}

Você obtém os mesmos resultados aplicando o @sealed() decorador à param declaração:

type anObject = {
  property: string
  optionalProperty: string?
}
 
@sealed() 
param aParameter anObject = {
  property: 'value'
  otionalProperty: 'value'
}

O mecanismo de implantação ARM também verifica os tipos selados em busca de propriedades adicionais. O fornecimento de quaisquer propriedades extras para parâmetros selados resulta em um erro de validação, fazendo com que a implantação falhe. Por exemplo:

@sealed()
type anObject = {
  property: string
}

param aParameter anObject = {
  property: 'value'
  optionalProperty: 'value'
}

Tipo de dados de união marcados

Para declarar um tipo de dados de união marcado personalizado em um arquivo Bicep, você pode colocar um discriminator decorador acima de uma declaração de tipo definida pelo usuário. Bicep CLI versão 0.21.X ou superior é necessário para usar este decorador. O exemplo a seguir mostra como declarar um tipo de dados união marcado:

type FooConfig = {
  type: 'foo'
  value: int
}

type BarConfig = {
  type: 'bar'
  value: bool
}

@discriminator('type')
type ServiceConfig = FooConfig | BarConfig | { type: 'baz', *: string }

param serviceConfig ServiceConfig = { type: 'bar', value: true }

output config object = serviceConfig

Para obter mais informações, consulte Tipo de dados de união com tags personalizadas.

Importar tipos entre arquivos Bicep

Somente os tipos de dados definidos pelo usuário que ostentam o @export() decorador podem ser importados para outros modelos.

O exemplo a seguir permite importar os dois tipos de dados definidos pelo usuário de outros modelos:

@export()
type myStringType = string

@export()
type myOtherStringType = myStringType

Para obter mais informações, consulte Importar tipos de dados definidos pelo usuário.

Próximos passos

• Para obter uma lista dos tipos de dados Bicep, consulte Tipos de dados.