|
6 | 6 | - [Opción 1: Descargarla de un recurso existente en Azure Portal](#opción-1-descargarla-de-un-recurso-existente-en-azure-portal)
|
7 | 7 | - [Opción 2: Descargar la plantilla de todo un grupo de recursos](#opción-2-descargar-la-plantilla-de-todo-un-grupo-de-recursos)
|
8 | 8 | - [Opción 3: Obtenerla de la comunidad](#opción-3-obtenerla-de-la-comunidad)
|
9 |
| - - [Implementa tu plantilla](#implementa-tu-plantilla) |
10 | 9 |
|
11 | 10 | :book: **Plantilla de Azure Resource Manager (ARM)**: es un archivo de notación de objetos JavaScript (JSON) que contiene la infraestructura y la configuración del proyecto. En la plantilla se especifican los recursos que se van a implementar y las propiedades de esos recursos.
|
12 | 11 |
|
13 | 12 | ## Crea tu plantilla
|
14 | 13 |
|
| 14 | +Puedes obtener una plantilla de ARM o puedes crearla tu para hacer tus propias configuraciones de recursos de Azure. |
| 15 | + |
| 16 | +1. Abre cualquier editor de código o IDE. Te recomiendo Visual Studio Code e instalar la extensión [Azure Resource Manager (ARM) Tools](https://marketplace.visualstudio.com/items?itemName=msazurermtools.azurerm-vscode-tools) |
| 17 | +2. Crea un archivo llamado `azuredeploy.json` |
| 18 | +3. Copia y pega lo siguiente que es la base de la plantilla |
| 19 | +```JSON |
| 20 | +{ |
| 21 | + "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#", |
| 22 | + "contentVersion": "1.0.0.0", |
| 23 | + "resources": [] |
| 24 | +} |
| 25 | +``` |
| 26 | + |
| 27 | +- `$schema`: Especifica la ubicación del archivo de esquema JSON. El archivo de esquema describe las propiedades que están disponibles dentro de una plantilla |
| 28 | +- `contentVersion`: Especifica la versión de la plantilla (por ejemplo, 1.0.0.0) |
| 29 | +- `resources`: Contiene los recursos que desea implementar o actualizar. Actualmente está vacía, pero agregará recursos más adelante |
| 30 | + |
| 31 | +4. Ejecuta el comando en el [CLI de Azure ](https://docs.microsoft.com/es-es/cli/azure/install-azure-cli) suplantando las palabras en mayúsculas por la información que corresponde a tu caso. |
| 32 | +``` |
| 33 | +az deployment group create \ |
| 34 | + --name NOMBRE_PLANTILLA \ |
| 35 | + --resource-group NOMBRE_GRUPO_RECURSOS \ |
| 36 | + --template-file DIRECCION_ARCHIVO_PLANTILLA |
| 37 | +``` |
| 38 | +**Tip**: Posicionate en la misma carpeta que en la que eesta el archivo json. |
| 39 | + |
| 40 | +**Nota**: En el Azure CLI de Windows cambia las diagonales **\\** Por el simbolo de potencia **^** (no aplica para PowerShell). |
| 41 | + |
| 42 | +Si te aparece lo siguiente quiere decir que la plantilla fue implementada con éxito: |
| 43 | +``` |
| 44 | +"ProvisioningState": "Succeeded", |
| 45 | +``` |
| 46 | + |
| 47 | +5. Ve a portal.azure.com y dirigete a tu grupo de recursos. Después da clic en Implementaciones o *Deplyments* |
| 48 | + |
| 49 | + |
| 50 | + |
| 51 | +6. Aquí encontrarás la plantilla que acabas de crear junto con todas las implementaciones que se han hecho desde Azure Portal, Cloud Shell o Azure CLI |
| 52 | + |
| 53 | + |
| 54 | + |
| 55 | +Si el nombre de tu plantilla aparece como correcta quiere decir que se implementó bien. Dentro ya puedes tener más información de su ejecución |
| 56 | + |
| 57 | +7. Ahora vamos a agregar un recurso a tu plantilla. Modificala de tal forma que quede así: |
| 58 | +```JSON |
| 59 | +{ |
| 60 | + "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#", |
| 61 | + "contentVersion": "1.0.0.0", |
| 62 | + "resources": [ |
| 63 | + { |
| 64 | + "type": "Microsoft.Storage/storageAccounts", |
| 65 | + "apiVersion": "2019-04-01", |
| 66 | + "name": "NOMBRE_RECURSO", |
| 67 | + "location": "eastus", |
| 68 | + "sku": { |
| 69 | + "name": "Standard_LRS" |
| 70 | + }, |
| 71 | + "kind": "StorageV2", |
| 72 | + "properties": { |
| 73 | + "supportsHttpsTrafficOnly": true |
| 74 | + } |
| 75 | + } |
| 76 | + ] |
| 77 | +} |
| 78 | +``` |
| 79 | +**Cambia las letras en mayúsculas por el nombre de recurso que desees.** |
| 80 | + |
| 81 | +Aquí estamos creando una cuenta de almacenamiento, que entre sus tantas funciones, te permite usar Azure Cloud Shell. |
| 82 | + |
| 83 | +**Nota**: el nombre de la cuenta de almacenamiento de Azure solo admite de 3 a 24 caracteres de letras mayúsculas o minúsculas y números. No caracteres especiales, espacios o guiones. |
| 84 | + |
| 85 | +Cada recurso implementado tiene al menos las siguientes tres propiedades: |
| 86 | + |
| 87 | +- `type`: tipo de recurso. Este valor es una combinación del espacio de nombres del proveedor de recursos y el tipo de recurso, como `Microsoft.Storage/storageAccounts` |
| 88 | +- `apiVersion`: Versión de la API de REST que debe usar para crear el recurso. Cada proveedor de recursos publica sus propias versiones de API, por lo que este valor es específico del tipo |
| 89 | +- `name`: Nombre del recurso |
| 90 | + |
| 91 | +Adicionalmente se agregaron otros campos como: |
| 92 | + |
| 93 | +- `location`: región de Azure en la que se implementará el recurso |
| 94 | +- `sku`: nivel de producto o servicio con el que se creará, en este caos Standard. |
| 95 | +- `kind`: tipo de almacenamidnto usado para el recurso. Este recurso puede no usarse para todos los casos. |
| 96 | +- `properties`: Se establecen propiedades especificas para este recurso. En este caso se le impone al recurso el solo permitir solicitudes HTTPS de salida y entrada. |
| 97 | + |
| 98 | +8. Ejecuta los pasos 4, 5 y 6 de nuevo. |
| 99 | + |
| 100 | +**Ahora, la plantilla que tenemos le vamos a agregar un parametro.** |
| 101 | + |
| 102 | +9. Vas a agregar lo siguiente en la plantilla. Esto debe estar en el primer nivel, es decir, al mismo nivel que `contentVersion` |
| 103 | + |
| 104 | + |
| 105 | +```JSON |
| 106 | +"parameters": { |
| 107 | + "storageName": { |
| 108 | + "type": "string", |
| 109 | + "minLength": 3, |
| 110 | + "maxLength": 24 |
| 111 | + } |
| 112 | + }, |
| 113 | +``` |
| 114 | + |
| 115 | +Dentro de `resources` debes agregar lo siguiente: |
| 116 | +```JSON |
| 117 | +"name": "[parameters('storageName')]", |
| 118 | +``` |
| 119 | + |
| 120 | +De tal forma que el código completo de la plantilla sea el siguiente: |
| 121 | + |
| 122 | +```JSON |
| 123 | +{ |
| 124 | + "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#", |
| 125 | + "contentVersion": "1.0.0.0", |
| 126 | + "parameters": { |
| 127 | + "storageName": { |
| 128 | + "type": "string", |
| 129 | + "minLength": 3, |
| 130 | + "maxLength": 24 |
| 131 | + } |
| 132 | + }, |
| 133 | + "resources": [ |
| 134 | + { |
| 135 | + "type": "Microsoft.Storage/storageAccounts", |
| 136 | + "apiVersion": "2019-04-01", |
| 137 | + "name": "[parameters('storageName')]", |
| 138 | + "location": "eastus", |
| 139 | + "sku": { |
| 140 | + "name": "Standard_LRS" |
| 141 | + }, |
| 142 | + "kind": "StorageV2", |
| 143 | + "properties": { |
| 144 | + "supportsHttpsTrafficOnly": true |
| 145 | + } |
| 146 | + } |
| 147 | + ] |
| 148 | +} |
| 149 | +``` |
| 150 | + |
| 151 | +El parametro que estamos definiendo se llama `storageName` y es un *string* o cadena de caracteres que se ingresa la momento de invocar el template con Azure CLI. |
| 152 | + |
| 153 | +Este parametro permite ser usado a lo largo de toda la plantilla y podríamos poner un SKU común para todos los recursos, un nombre similar, la localización o cualquier cosa que queramos y sea compatible con el recurso y con la sintaxis de las plantillas. |
| 154 | + |
| 155 | +10. Para ejecutar este nueva plantilla necesitas ejecutar el siguiente comando sustituyendo los valores en las palabras en mayusculas: |
| 156 | + |
| 157 | + |
| 158 | +``` |
| 159 | +az deployment group create \ |
| 160 | + --name NOMBRE_PLANTILLA \ |
| 161 | + --resource-group NOMBRE_GRUPO_RECURSOS \ |
| 162 | + --template-file DIRECCION_ARCHIVO_PLANTILLA \ |
| 163 | + --parameters storageName=VALOR_storageName |
| 164 | +``` |
| 165 | + |
| 166 | +**Nota**: Lo que pongas en vez de VALOR_storageName será el valor que tenga esta variable dentro de toda la plantilla. Estos parametros se pueden considerar como constantes en un lenguaje de programación. |
| 167 | + |
| 168 | +**Y así como podemos poner parametros o constantes, también podemos colocar variables** |
| 169 | + |
| 170 | +11. Agregarás a tu plantilla lo siguiente: |
| 171 | + |
| 172 | +```JSON |
| 173 | +"storagePrefix": { |
| 174 | + "type": "string", |
| 175 | + "minLength": 3, |
| 176 | + "maxLength": 11 |
| 177 | + }, |
| 178 | + |
| 179 | +"variables": { |
| 180 | + "uniqueStorageName": "[concat(parameters('storagePrefix'), uniqueString(resourceGroup().id))]" |
| 181 | + }, |
| 182 | + |
| 183 | +"name": "[variables('uniqueStorageName')]", |
| 184 | + |
| 185 | +``` |
| 186 | + |
| 187 | +Dando como resultado lo siguiente: |
| 188 | + |
| 189 | +```JSON |
| 190 | +{ |
| 191 | + "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#", |
| 192 | + "contentVersion": "1.0.0.0", |
| 193 | + "parameters": { |
| 194 | + "storagePrefix": { |
| 195 | + "type": "string", |
| 196 | + "minLength": 3, |
| 197 | + "maxLength": 11 |
| 198 | + } |
| 199 | + }, |
| 200 | + "variables": { |
| 201 | + "uniqueStorageName": "[concat(parameters('storagePrefix'), uniqueString(resourceGroup().id))]" |
| 202 | + }, |
| 203 | + "resources": [ |
| 204 | + { |
| 205 | + "type": "Microsoft.Storage/storageAccounts", |
| 206 | + "apiVersion": "2019-04-01", |
| 207 | + "name": "[variables('uniqueStorageName')]", |
| 208 | + "location": "eastus", |
| 209 | + "sku": { |
| 210 | + "name": "Standard_LRS" |
| 211 | + }, |
| 212 | + "kind": "StorageV2", |
| 213 | + "properties": { |
| 214 | + "supportsHttpsTrafficOnly": true |
| 215 | + } |
| 216 | + } |
| 217 | + ] |
| 218 | +} |
| 219 | +``` |
| 220 | + |
| 221 | +En la sección variables se une el valor que introduces en el CLI como storagePrefix con un *string* aleatorio, esto con el fin de evitar que se repitan los nombres en los mismos recursos y pueda derivar en un error de implementación. |
| 222 | + |
| 223 | +12. Ejecutas la plantilla de ARM con el siguiente comando de Azure CLI |
| 224 | + |
| 225 | +``` |
| 226 | +az deployment group create \ |
| 227 | + --name NOMBRE_PLANTILLA \ |
| 228 | + --resource-group NOMBRE_GRUPO_RECURSOS \ |
| 229 | + --template-file DIRECCION_ARCHIVO_PLANTILLA \ |
| 230 | + --parameters storagePrefix=VALOR_storagePrefix |
| 231 | +``` |
| 232 | + |
| 233 | +Después de la ejecución exitosa de este comando te debe de crear un recurso similar a este: |
| 234 | + |
| 235 | + |
| 236 | + |
| 237 | +Si quieres aprender más sobre la creación de las plantillas consulta la siguiente documentación: |
| 238 | +- [Documentación de las plantillas de Resource Manager |
| 239 | +](https://docs.microsoft.com/es-mx/azure/azure-resource-manager/templates/) |
| 240 | +- [Buenas practicas para plantillas ARM](https://github.com/Azure/azure-quickstart-templates/blob/master/) |
15 | 241 |
|
16 | 242 | ## Obtener una plantilla de ARM ya hecha
|
17 | 243 |
|
@@ -64,5 +290,3 @@ Donde puedes:
|
64 | 290 |
|
65 | 291 | 
|
66 | 292 |
|
67 |
| -## Implementa tu plantilla |
68 |
| - |
|
0 commit comments