Bicep: IaC moderna para Azure
Aprenda la sintaxis concisa de Bicep como abstracción fuertemente tipada sobre JSON de ARM, convierta una plantilla de ARM existente a Bicep e impleméntela con Azure CLI.
Bicep: IaC moderna para Azure es una lección gratuita de Cloud & IT Cert Prep en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Cloud & IT Cert Prep, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Cloud & IT Cert Prep incluye 4 lecciones en total.
¿Qué es Bicep y por qué utilizarlo?
Bicep es un lenguaje específico de dominio (DSL) desarrollado por Microsoft como alternativa concisa y con tipado fuerte a las plantillas JSON de ARM. Bicep se compila en JSON de ARM estándar, por lo que utiliza el mismo motor de implementación de ARM y admite todos los tipos de recursos de Azure desde el primer día. Bicep elimina gran parte del código repetitivo necesario en JSON sin procesar y proporciona una mejor seguridad de tipos y compatibilidad con IntelliSense.
Comparación de la sintaxis de Bicep y ARM JSON
La misma cuenta de almacenamiento que requiere aproximadamente 25 líneas de JSON en una plantilla de ARM solo necesita unas 8 líneas en Bicep. Bicep elimina '$schema', contentVersion, el contenedor de la matriz resources y la sintaxis de expresiones extensa. Los nombres y tipos de las propiedades siguen siendo idénticos, ya que Bicep es una capa de abstracción directa sobre ARM JSON; no hay ninguna diferencia en tiempo de ejecución.
// Bicep: deploy a storage account
param storageAccountName string
param location string = resourceGroup().location
param sku string = 'Standard_LRS'
resource storageAccount 'Microsoft.Storage/storageAccounts@2023-01-01' = {
name: storageAccountName
location: location
sku: {
name: sku
}
kind: 'StorageV2'
properties: {
supportsHttpsTrafficOnly: true
minimumTlsVersion: 'TLS1_2'
}
}Parámetros y decoradores en Bicep
Los parámetros de Bicep utilizan la sintaxis concisa param name type = defaultValue. Puede aplicar decoradores (con el prefijo @) directamente encima de un parámetro para agregar restricciones como @minLength(), @maxLength(), @allowed() y @description(). El decorador @secure() marca un parámetro como confidencial y equivale a secureString en ARM JSON.
@description('Globally unique name for the storage account')
@minLength(3)
@maxLength(24)
param storageAccountName string
@allowed(['Standard_LRS', 'Standard_GRS', 'Premium_LRS'])
param sku string = 'Standard_LRS'
@secure()
param adminPassword stringVariables y expresiones en Bicep
Las variables de Bicep se declaran con la palabra clave var y pueden contener cualquier expresión, incluida la interpolación de cadenas mediante la sintaxis '${value}'. La interpolación de cadenas es una de las mejoras de legibilidad más destacadas frente a ARM JSON: ya no es necesario utilizar llamadas a la función concat(). Bicep también admite expresiones condicionales mediante el operador ternario condition ? trueValue : falseValue.
param environment string = 'dev'
param baseName string = 'myapp'
var uniqueSuffix = uniqueString(resourceGroup().id)
var storageAccountName = '${baseName}${environment}${uniqueSuffix}'
var isProd = environment == 'prod'
var skuName = isProd ? 'Standard_GRS' : 'Standard_LRS'Declaraciones de recursos y nombres simbólicos
En Bicep, cada recurso recibe un nombre simbólico: un identificador que se utiliza para hacer referencia a él dentro de la plantilla. El nombre simbólico no es el mismo que el nombre del recurso en Azure. Utilice nombres simbólicos para acceder a las propiedades de los recursos y establecer dependencias implícitas haciendo referencia a un recurso dentro de otro, lo que elimina la necesidad de una matriz dependsOn explícita.
resource vnet 'Microsoft.Network/virtualNetworks@2023-05-01' = {
name: 'myVNet'
location: location
properties: {
addressSpace: { addressPrefixes: ['10.0.0.0/16'] }
}
}
// Implicit dependency via symbolic name reference
resource subnet 'Microsoft.Network/virtualNetworks/subnets@2023-05-01' = {
parent: vnet // Bicep knows to create vnet first
name: 'mySubnet'
properties: {
addressPrefix: '10.0.1.0/24'
}
}Salidas en Bicep
Las salidas de Bicep se declaran con la palabra clave output, seguida del nombre, el tipo y el valor de la salida. Puede hacer referencia a las propiedades de un recurso implementado mediante el nombre simbólico y la notación de punto, que resulta mucho más legible que la función reference() de ARM. Las salidas son esenciales para pasar valores entre llamadas a módulos de Bicep.
output storageAccountName string = storageAccount.name
output blobEndpoint string = storageAccount.properties.primaryEndpoints.blob
output storageAccountId string = storageAccount.idMódulos de Bicep
Los módulos de Bicep son el equivalente de las plantillas vinculadas en ARM JSON y permiten dividir la infraestructura en componentes reutilizables. Un módulo es simplemente otro archivo .bicep. Puede hacer referencia a él mediante la palabra clave module, pasar parámetros y utilizar sus salidas. También puede publicar módulos en un Azure Container Registry y consumirlos desde allí para reutilizarlos en todo el equipo.
// main.bicep — consuming a storage module
module storage './modules/storage.bicep' = {
name: 'storageDeploy'
params: {
storageAccountName: 'myuniquestorage'
location: location
sku: 'Standard_LRS'
}
}
// Reference module output in parent template
output blobUri string = storage.outputs.blobEndpointConvertir plantillas de ARM a Bicep
Si ya dispone de plantillas ARM JSON, la CLI de Bicep puede descompilarlas a Bicep mediante bicep decompile. Es posible que el resultado requiera algunos ajustes manuales, pero proporciona un excelente punto de partida. Microsoft también ofrece un playground en línea en aka.ms/bicepdemo, donde puede pegar código ARM JSON y ver el Bicep equivalente en tiempo real.
# Install the Bicep CLI (or use it via Azure CLI)
az bicep install
az bicep upgrade
# Decompile existing ARM JSON to Bicep
az bicep decompile --file azuredeploy.json
# Produces azuredeploy.bicep in the same directory
# Compile Bicep to ARM JSON (for inspection)
az bicep build --file main.bicepImplementar Bicep con Azure CLI
Azure CLI admite directamente los archivos de Bicep; no es necesario compilarlos manualmente a ARM JSON antes de implementarlos. Pase la ruta del archivo .bicep a az deployment group create mediante la opción --template-file, y la CLI lo compilará de forma transparente. Los mismos subcomandos validate y what-if funcionan con archivos de Bicep exactamente igual que con ARM JSON.
# Deploy a Bicep file directly
az deployment group create \
--resource-group MyRG \
--template-file main.bicep \
--parameters storageAccountName=myprodstore environment=prod
# What-if preview with Bicep
az deployment group what-if \
--resource-group MyRG \
--template-file main.bicep \
--parameters storageAccountName=myprodstore environment=prodBucles y condiciones en Bicep
Bicep admite bucles de recursos mediante la sintaxis for ... in para crear varias instancias de un recurso a partir de un parámetro de tipo matriz, lo que evita duplicar código mediante copiar y pegar. La palabra clave if permite la implementación condicional de recursos: un recurso solo se incluye cuando se cumple una condición determinada. Ambas características se compilan, respectivamente, en las construcciones copy y condition de ARM.
// Loop: create multiple storage accounts
param storageNames array = ['alpha', 'beta', 'gamma']
resource stores 'Microsoft.Storage/storageAccounts@2023-01-01' = [for name in storageNames: {
name: '${name}${uniqueString(resourceGroup().id)}'
location: location
sku: { name: 'Standard_LRS' }
kind: 'StorageV2'
}]
// Condition: only deploy in prod
param deployKeyVault bool = false
resource kv 'Microsoft.KeyVault/vaults@2023-07-01' = if (deployKeyVault) {
name: 'myKeyVault'
location: location
properties: { sku: { family: 'A', name: 'standard' }, tenantId: subscription().tenantId, accessPolicies: [] }
}Herramientas y linting de Bicep
La extensión de Bicep para Visual Studio Code proporciona IntelliSense avanzado, comprobación de tipos y resaltado de errores en línea mientras escribe. La CLI de Bicep incluye un linter que comprueba infracciones de las prácticas recomendadas, como parámetros sin usar, descripciones ausentes y versiones de API incorrectas. Ejecute az bicep lint --file main.bicep en su canalización de CI para detectar problemas antes de la implementación.
# Run the Bicep linter
az bicep lint --file main.bicep
# Format a Bicep file
az bicep format --file main.bicep
# Generate resource type documentation
az bicep generate-params --file main.bicep --output-format jsonComprobación rápida
Compruebe su comprensión de los conceptos de Microsoft Azure Fundamentals (AZ-900) tratados en esta lección.
Resumen de la lección
En esta lección ha aprendido que Bicep es una abstracción concisa y fuertemente tipada sobre ARM JSON que se compila en plantillas ARM estándar; los módulos y bucles permiten crear código de infraestructura reutilizable y DRY; y Azure CLI implementa directamente los archivos de Bicep mediante el mismo flujo de trabajo de validación, what-if e implementación. A continuación, exploraremos Terraform en Azure.
Preguntas frecuentes
¿La lección «Bicep: IaC moderna para Azure» es gratis?
Sí — el texto completo de «Bicep: IaC moderna para Azure» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Cloud & IT Cert Prep, actualiza a CoddyKit PRO. El curso de Cloud & IT Cert Prep incluye 4 lecciones en total.
¿Qué aprenderé en «Bicep: IaC moderna para Azure»?
Aprenda la sintaxis concisa de Bicep como abstracción fuertemente tipada sobre JSON de ARM, convierta una plantilla de ARM existente a Bicep e impleméntela con Azure CLI. Practicas Cloud & IT Cert Prep con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Cloud & IT Cert Prep?
No se requiere experiencia previa. Cloud & IT Cert Prep en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.
¿Cuánto tiempo toma la lección «Bicep: IaC moderna para Azure»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Cloud & IT Cert Prep?
Sí. Cada lección de Cloud & IT Cert Prep incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Cómo funciona Azure Resource Manager
- Redacción de plantillas de ARM
- Bicep: IaC moderna para Azure
- Terraform en Azure