Redacción de plantillas de ARM
Cree en JSON una plantilla de ARM parametrizada para implementar una cuenta de almacenamiento y una máquina virtual, y use funciones y variables de plantilla para hacer que las plantillas sean reutilizables.
Redacción de plantillas de ARM es una lección gratuita de Cloud & IT Cert Prep en CoddyKit. Esta es la lección 2 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.
¿Por qué usar plantillas de ARM?
Las plantillas de ARM permiten definir la infraestructura de Azure como código en formato JSON. Esto permite realizar implementaciones repetibles y coherentes, además de controlarlas mediante versiones junto con el código de la aplicación. Las plantillas son idempotentes: ejecutar la misma plantilla varias veces produce el mismo resultado, por lo que es seguro volver a aplicarlas después de realizar cambios.
Estructura básica y esquema de la plantilla
Toda plantilla de ARM comienza con una propiedad $schema que apunta a la URL del esquema de la plantilla, seguida de una cadena contentVersion. El esquema indica al portal de Azure y a las extensiones del editor cómo validar la plantilla y proporcionar IntelliSense. Las cinco secciones principales que siguen son parameters, variables, functions, resources y outputs.
{
'$schema': 'https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#',
'contentVersion': '1.0.0.0',
'parameters': {},
'variables': {},
'functions': [],
'resources': [],
'outputs': {}
}Definición de parámetros
Los parámetros hacen que las plantillas sean reutilizables al aceptar entradas durante la implementación. Cada parámetro tiene un type (string, int, bool, object, array, secureString), un defaultValue opcional y allowedValues opcionales para la validación. Utilizar secureString para las contraseñas garantiza que el valor nunca se registre en el historial de implementación.
"parameters": {
"storageAccountName": {
"type": "string",
"minLength": 3,
"maxLength": 24,
"metadata": { "description": "Globally unique storage account name" }
},
"sku": {
"type": "string",
"defaultValue": "Standard_LRS",
"allowedValues": ["Standard_LRS", "Standard_GRS", "Premium_LRS"]
}
}Uso de variables para valores calculados
Las variables almacenan valores calculados a partir de parámetros o funciones de plantilla, lo que reduce la repetición y facilita el mantenimiento de las plantillas. Las variables se evalúan una vez y se referencian en toda la sección de recursos mediante la expresión [variables('name')]. Un patrón habitual consiste en crear el nombre de un recurso concatenando un parámetro con un sufijo único.
"variables": {
"uniqueStorageName": "[concat(parameters('storageAccountName'), uniqueString(resourceGroup().id))]",
"location": "[resourceGroup().location]"
}Definición de recursos
La matriz resources es el núcleo de una plantilla de ARM. Cada elemento describe un recurso de Azure con los campos obligatorios: type, apiVersion, name y location. apiVersion fija la versión del esquema del proveedor de recursos. Utilice siempre una versión estable reciente para acceder a las funciones más recientes y evitar propiedades en desuso.
"resources": [
{
"type": "Microsoft.Storage/storageAccounts",
"apiVersion": "2023-01-01",
"name": "[variables('uniqueStorageName')]",
"location": "[variables('location')]",
"sku": { "name": "[parameters('sku')]" },
"kind": "StorageV2",
"properties": {
"supportsHttpsTrafficOnly": true,
"minimumTlsVersion": "TLS1_2"
}
}
]Funciones y expresiones de plantilla
Las expresiones de las plantillas de ARM están delimitadas por corchetes [...] y admiten funciones integradas para cadenas, matrices, objetos e identificadores de recursos. Entre las funciones habituales se incluyen concat(), resourceGroup(), resourceId(), uniqueString() y parameters(). ARM evalúa estas funciones en el servidor durante la implementación, no localmente.
// Reference a resource ID inside a template
"subnetId": "[resourceId('Microsoft.Network/virtualNetworks/subnets', 'myVNet', 'mySubnet')]"
// Build a unique, deterministic name
"name": "[concat('storage', uniqueString(resourceGroup().id))]"
// Conditionally include a resource
"condition": "[equals(parameters('deployStorage'), true)]"Outputs: devolución de valores
La sección outputs define los valores que ARM devuelve después de una implementación correcta. Los outputs son esenciales para encadenar plantillas: puede implementar una plantilla de red y devolver el identificador de recurso de la subred, y luego pasarlo como parámetro a una plantilla de máquina virtual. Los outputs pueden hacer referencia a cualquier expresión, incluidas las propiedades de recursos de la implementación.
"outputs": {
"storageAccountName": {
"type": "string",
"value": "[variables('uniqueStorageName')]"
},
"blobEndpoint": {
"type": "string",
"value": "[reference(variables('uniqueStorageName')).primaryEndpoints.blob]"
}
}Plantillas vinculadas y anidadas
Para arquitecturas complejas, ARM admite plantillas vinculadas (que hacen referencia a URL de plantillas externas) y plantillas anidadas (que integran una plantilla dentro de la matriz de recursos mediante el tipo Microsoft.Resources/deployments). Esto permite dividir una implementación de infraestructura grande en componentes modulares y reutilizables, manteniendo una única plantilla de orquestación como punto de entrada.
{
"type": "Microsoft.Resources/deployments",
"apiVersion": "2021-04-01",
"name": "networkDeploy",
"properties": {
"mode": "Incremental",
"templateLink": {
"uri": "https://raw.githubusercontent.com/contoso/templates/main/network.json",
"contentVersion": "1.0.0.0"
},
"parameters": {
"vnetName": { "value": "[parameters('vnetName')]" }
}
}
}Archivos de parámetros
En lugar de pasar los parámetros en la línea de comandos, almacénelos en un archivo de parámetros independiente: un archivo JSON con un objeto parameters que contiene pares de nombre y valor. Los archivos de parámetros pueden ser específicos de cada entorno (por ejemplo, dev.parameters.json y prod.parameters.json) y confirmarse en el control de código fuente, manteniendo los valores confidenciales en referencias a Azure Key Vault en lugar de texto sin formato.
// dev.parameters.json
{
'$schema': 'https://schema.management.azure.com/schemas/2019-04-01/deploymentParameters.json#',
'contentVersion': '1.0.0.0',
'parameters': {
'storageAccountName': { 'value': 'devstorageacct' },
'sku': { 'value': 'Standard_LRS' }
}
}
// Deploy with parameters file
// az deployment group create -g MyRG -f azuredeploy.json -p dev.parameters.jsonImplementación y validación de plantillas
Utilice el comando de Azure CLI az deployment group create para implementar una plantilla en un grupo de recursos. Antes de realizar la implementación en producción, ejecute az deployment group validate para detectar errores de esquema y lógica, y az deployment group what-if para previsualizar los cambios en los recursos. Estos tres comandos forman una canalización de implementación segura: validar, previsualizar e implementar.
# Step 1: Validate the template syntax
az deployment group validate \
--resource-group MyRG \
--template-file azuredeploy.json \
--parameters @dev.parameters.json
# Step 2: Preview changes
az deployment group what-if \
--resource-group MyRG \
--template-file azuredeploy.json \
--parameters @dev.parameters.json
# Step 3: Deploy
az deployment group create \
--resource-group MyRG \
--template-file azuredeploy.json \
--parameters @dev.parameters.jsonProcedimientos recomendados para las plantillas de ARM
Siga estos procedimientos recomendados para las plantillas de ARM: utilice parámetros para los valores específicos de cada entorno, utilice variables para evitar repeticiones, fije las versiones de API en versiones estables, utilice secureString para las contraseñas, agregue descripciones de metadatos a los parámetros y separe las plantillas grandes en módulos vinculados. Almacene las plantillas en un repositorio de Git e impleméntelas mediante una canalización de CI/CD para facilitar la auditoría.
Comprobación rápida
Compruebe su comprensión de los conceptos de Microsoft Azure Fundamentals (AZ-900) de esta lección.
Resumen de la lección
En esta lección ha aprendido que las plantillas de ARM son documentos JSON que definen declarativamente la infraestructura de Azure; los parámetros y las variables hacen que las plantillas sean reutilizables y fáciles de mantener; y el flujo de trabajo validate, what-if, deploy permite realizar implementaciones seguras y repetibles. A continuación, exploraremos Bicep, una abstracción moderna de ARM JSON.
Preguntas frecuentes
¿La lección «Redacción de plantillas de ARM» es gratis?
Sí — el texto completo de «Redacción de plantillas de ARM» 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 «Redacción de plantillas de ARM»?
Cree en JSON una plantilla de ARM parametrizada para implementar una cuenta de almacenamiento y una máquina virtual, y use funciones y variables de plantilla para hacer que las plantillas sean reutil… 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 2 de 4.
¿Cuánto tiempo toma la lección «Redacción de plantillas de ARM»?
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