Tipos de dados definidos pelo usuário no Bicep

  • Artigo

Saiba como usar tipos de dados definidos pelo usuário no Bicep.

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

Sintaxe do tipo de dados definido pelo usuário

Você pode usar a type instrução para definir 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>

Nota

O @allowed decorador só é permitido em param declarações. Para declarar que uma propriedade deve ser um de um conjunto de valores predefinidos em uma type instrução or output , use a sintaxe do tipo união. A sintaxe do tipo União também pode ser usada em param instruções.

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 ) ou intum 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

  • Os tipos de matriz podem ser declarados por sufixação [] 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 chave e valor. A chave e o valor são separados por dois pontos :. A chave pode ser qualquer cadeia de caracteres (valores que não seriam um identificador válido devem ser colocados entre aspas) e o valor pode ser qualquer expressão de sintaxe de tipo.

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

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

    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 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, , , , level4level2level3ou 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

  • Os sindicatos 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@2022-09-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@2022-09-01' = {
  name: storageAccountConfig.name
  location: location
  sku: {
    name: storageAccountConfig.sku
  }
  kind: 'StorageV2'
}

Declarar tipo de união marcada

Para declarar um tipo de dados de união marcado personalizado em um arquivo Bicep, você pode colocar um decorador discriminador 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. A sintaxe é:

@discriminator('<propertyName>')

O decorador discriminador usa um único parâmetro, que representa um nome de propriedade compartilhada entre todos os membros do sindicato. Esse nome de propriedade deve ser uma cadeia de caracteres literal necessária em todos os membros e diferencia maiúsculas de minúsculas. Os valores dos bens discriminados sobre os membros do sindicato devem ser únicos de forma insensível a maiúsculas e minúsculas.

O exemplo a seguir mostra como declarar um tipo de 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

O valor do parâmetro é validado com base no valor da propriedade discriminada. No exemplo anterior, se o valor do parâmetro serviceConfig for do tipo foo, ele passará por validação usando o tipo FooConfig. Da mesma forma, se o valor do parâmetro for de barra de tipo, a validação será executada usando o tipo BarConfig, e esse padrão continuará para outros tipos também.

Importar tipos entre arquivos Bicep (Visualização)

A CLI do Bicep versão 0.21.X ou superior é necessária para usar esse recurso de importação em tempo de compilação. O sinalizador compileTimeImports experimental deve ser ativado a partir do arquivo de configuração do Bicep.

Somente os tipos de dados definidos pelo usuário que ostentam o @export() decorador podem ser importados para outros modelos. Atualmente, este decorador só pode ser usado em type declarações.

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.