Tipos de datos definidos por el usuario en Bicep

  • Artículo

Aprende a usar tipos de datos definidos por el usuario en Bicep.

Para usar esta característica se necesita la versión 0.12.X o posterior de la CLI de Bicep.

Sintaxis de tipo de datos definida por el usuario

Puedes usar la instrucción type para definir tipos de datos definidos por el usuario. Además, también puedes usar expresiones de tipo en algunos lugares para definir tipos personalizados.

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

Nota:

El decorador ,@allowed y solo se permite en las instrucciones, param y . Para declarar que una propiedad debe ser uno de un conjunto de valores predefinidos en una instruccióntype o output, use la sintaxis de tipo de unión. La sintaxis de tipo de unión también se puede usar en instrucciones ,param y .

Las expresiones de tipo válidas incluyen:

  • Las referencias simbólicas son identificadores que hacen referencia a un tipo ambiente (como string o int) o a un símbolo de tipo definido por el usuario declarado en una instrucción type:

    // Bicep data type reference
type myStringType = string

// user-defined type reference
type myOtherStringType = myStringType

  • Los literales primitivos, incluidas las cadenas, los enteros y los booleanos, son expresiones de tipo válidas. Por ejemplo:

    // 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

  • Los tipos de matriz se pueden declarar mediante sufijos [] en cualquier expresión 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)[]

  • Los tipos de objeto contienen cero o más propiedades entre corchetes:

    type storageAccountConfigType = {
  name: string
  sku: string
}

    Cada propiedad de un objeto consta de una clave y un valor. La clave y el valor están separados por dos puntos :. La clave puede ser cualquier cadena (los valores que no serían un identificador válido deben estar entre ofertas), y el valor puede ser cualquier tipo de expresión de sintaxis.

    Las propiedades son necesarias a menos que tengan un marcador de opcionalidad ? después del nombre de propiedad y los dos puntos. Por ejemplo, la propiedad sku del ejemplo siguiente es opcional:

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

    Los decoradores se pueden usar en propiedades. * puede utilizarse para que todos los valores requieran una restricción. Es posible que todavía se definan propiedades adicionales al usar *. En este ejemplo se crea un objeto que requiere una clave de tipo int denominada id y que todas las demás entradas del objeto deben ser un valor de cadena de al menos 10 caracteres.

    type obj = {
  @description('The object ID')
  id: int

  @description('Additional properties')
  @minLength(10)
  *: string
}

    En el ejemplo siguiente se muestra cómo usar la sintaxis de tipo de unión para enumerar un conjunto de valores predefinidos:

    type obj = {
  level: 'bronze' | 'silver' | 'gold'
}

    Recursividad

    Los tipos de objeto pueden usar recursividad directa o indirecta, siempre y cuando al menos la pierna de la ruta de acceso al punto de recursividad sea opcional. Por ejemplo, la definición myObjectType del ejemplo siguiente es válida porque la propiedad directamente recursiva recursiveProp es opcional:

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

    Pero la siguiente definición de tipo no sería válida porque ninguna de level1, level2, level3, level4 o level5 es opcional.

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

  • Los operadores unarios de Bicep se pueden usar con literales enteros y booleanos o referencias a símbolos de tipo literal booleano o entero:

    type negativeIntLiteral = -10
type negatedIntReference = -negativeIntLiteral

type negatedBoolLiteral = !true
type negatedBoolReference = !negatedBoolLiteral

  • Las uniones pueden incluir cualquier número de expresiones con tipo literal. Los tipos de unión se traducen en la restricción de valor permitido en Bicep, por lo que solo se permiten literales como miembros.

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

Además de usarse en la instrucción type, las expresiones de tipo también se pueden usar en estos lugares para crear tipos de datos definidos por el usuario:

  • Como la cláusula tipo de una instrucción param. Por ejemplo:

    param storageAccountConfig {
  name: string
  sku: string
}

  • Después de : en una propiedad de tipo de objeto. Por ejemplo:

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

  • Anterior a [] en una expresión de tipo de matriz. Por ejemplo:

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

Un archivo de Bicep típico para crear una cuenta de almacenamiento tiene el siguiente aspecto:

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'
}

Mediante el uso de tipos de datos definidos por el usuario, puede tener el siguiente aspecto:

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'
}

Declaración del tipo de unión etiquetado

Para declarar un tipo de datos de unión etiquetado personalizado dentro de un archivo de Bicep, puede colocar un decorador discriminador encima de una declaración de tipo definido por el usuario. Para usar este decorador se necesita la versión 0.21.X o posterior de la CLI de Bicep. La sintaxis es:

@discriminator('<propertyName>')

El decorador discriminador toma un único parámetro, que representa un nombre de propiedad compartida entre todos los miembros de la unión. Este nombre de propiedad debe ser un literal de cadena obligatorio en todos los miembros y distingue mayúsculas de minúsculas. Los valores de la propiedad discriminada en los miembros de la unión deben ser únicos de una manera sin distinción entre mayúsculas y minúsculas.

En el ejemplo siguiente se muestra cómo declarar un tipo de unión etiquetado:

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

El valor del parámetro se valida en función del valor de la propiedad discriminada. En el ejemplo anterior, si el valor del parámetro serviceConfig fuera de tipo foo, se someterá a la validación mediante el tipo FooConfig. Del mismo modo, si el valor del parámetro es de barra de tipo, la validación se realiza en el tipo BarConfig y este patrón continúa también para otros tipos.

Importación de tipos entre archivos de Bicep (versión preliminar)

Para usar esta característica de importación en tiempo de compilación se necesita la versión 0.21.X o posterior de la CLI de Bicep. La marca compileTimeImports experimental debe estar habilitada desde el archivo de configuración de Bicep.

Sólo los tipos de datos definidos por el usuario que lleven el decorador @export() pueden importarse a otras plantillas. Actualmente, este decorador solo se puede usar en instrucciones type.

En el ejemplo siguiente se pueden importar los dos tipos de datos definidos por el usuario de otras plantillas:

@export()
type myStringType = string

@export()
type myOtherStringType = myStringType

Para obtener más información, consulte Importación de tipos de datos definidos por el usuario.

Pasos siguientes

  • Para obtener una lista de los tipos de datos de Bicep, consulte Tipos de datos.