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 Azure Fundamentals 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 Azure Fundamentals, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Azure Fundamentals 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 Azure Fundamentals, actualiza a CoddyKit PRO. El curso de Azure Fundamentals 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 Azure Fundamentals 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 Azure Fundamentals?
No se requiere experiencia previa. Azure Fundamentals 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 Azure Fundamentals?
Sí. Cada lección de Azure Fundamentals 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