Ejercicio: implementación de un flujo de trabajo de Azure Logic Apps básico con una plantilla de ARM

Completado

En esta unidad, implementaremos un flujo de trabajo en Azure Logic Apps con una plantilla de Azure Resource Manager.

Creación de recursos en Azure

Normalmente, creamos primero un grupo de recursos que contenga todo lo que necesitamos crear. Un grupo de recursos nos permite administrar todas las máquinas virtuales, los discos, las interfaces de red y otros elementos que componen la solución como una unidad.

Podemos crear un grupo de recursos con el comando az group create de la CLI de Azure. Este comando toma un --name para proporcionar un nombre de grupo de recursos único en nuestra suscripción. El comando también toma un --location para proporcionar la región predeterminada de Azure para los recursos.

Sin embargo, estamos usando el entorno de espacio aislado de Azure gratuito, por lo que no es necesario crear un grupo de recursos. En su lugar, puede usar el grupo de recursos creado anteriormente [nombre del grupo de recursos del espacio aislado] en este ejercicio.

Descargar y examinar una plantilla de Resource Manager básica

1. En la parte superior de la ventana de Cloud Shell, seleccione el icono Más (...) y a continuación, seleccione Configuración>Ir a la versión clásica.

2. En Cloud Shell, ejecute el siguiente comando curl para descargar la plantilla de GitHub:

   curl https://raw.githubusercontent.com/MicrosoftDocs/mslearn-logic-apps-and-arm-templates/master/basic-template/template.json > basic-template.json
   

3. Para ver la plantilla, ábrala en el editor integrado:

   code basic-template.json
   

   La definición del flujo de trabajo para la aplicación lógica que se describe en template.json aparece en la lista siguiente:

   {
       "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
       "contentVersion": "1.0.0.0",
       "parameters": {},
       "variables": {},
       "resources": [
           {
               "type": "Microsoft.Logic/workflows",
               "apiVersion": "2017-07-01",
               "name": "HelloLogicAppsTemplate",
               "location": "westus2",
               "properties": {
                   "state": "Enabled",
                   "definition": {
                       "$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
                       "contentVersion": "1.0.0.0",
                       "parameters": {},
                       "triggers": {
                           "manual": {
                               "type": "Request",
                               "kind": "Http",
                               "inputs": {
                                   "method": "GET",
                                   "schema": {}
                               }
                           }
                       },
                       "actions": {
                           "Response": {
                               "runAfter": {},
                               "type": "Response",
                               "kind": "Http",
                               "inputs": {
                                   "body": "Hello Logic Apps Template!",
                                   "statusCode": 200
                               }
                           }
                       },
                       "outputs": {}
                   },
                   "parameters": {}
               }
           }
       ],
       "outputs": {
           "logicAppUrl": {
              "type": "string",
              "value": "[listCallbackURL(concat(resourceId('Microsoft.Logic/workflows/', 'HelloLogicAppsTemplate'), '/triggers/manual'), '2017-07-01').value]"
           }
        }
   }
   

   Como puede ver en la definición de JSON anterior, y tal como sugiere el nombre de la plantilla, este flujo de trabajo de aplicación lógica es básico. Examinemos los componentes principales de esta aplicación.

   En el fragmento de código siguiente, podemos ver que la aplicación se llama HelloLogicAppsTemplate. Este nombre está codificado de forma rígida en la plantilla. La ubicación donde se ejecuta la aplicación también está codificada de forma rígida en westus2.

   "name": "HelloLogicAppsTemplate",
   "location": "westus2",
   

   Desplácese hacia abajo hasta la sección de desencadenadores, donde veremos que el flujo de trabajo se desencadena con una solicitud HTTP GET. El desencadenador se denomina manual.

   "triggers": {
       "manual": {
           "type": "Request",
           "kind": "Http",
           "inputs": {
               "method": "GET",
               "schema": {}
           }
       }
   },
   

   Más adelante en la sección de acciones, aprenderemos que este flujo de trabajo contiene un paso o una acción. Esta acción responde a la solicitud con el mensaje Hello Azure Logic Apps Template!.

   "actions": {
       "Response": {
           "runAfter": {},
           "type": "Response",
           "kind": "Http",
           "inputs": {
               "body": "Hello Logic Apps Template!",
               "statusCode": 200
           }
       }
   },
   

   La sección salidas de la plantilla de Resource Manager tiene una única salida denominada logicAppUrl. Esta variable de salida enumera la dirección URL para el recurso de aplicación lógica cuando se implementa. Esta dirección URL facilita la prueba de la aplicación. La salida usa listCallbackURL para crear la URL, pero el nombre del flujo de trabajo y el nombre del desencadenador están codificados a fuego aquí.

   "outputs": {
       "logicAppUrl": {
          "type": "string",
          "value": "[listCallbackURL(concat(resourceId('Microsoft.Logic/workflows/', 'HelloLogicAppsTemplate'), '/triggers/manual'), '2017-07-01').value]"
       }
    }
   

   Ahora implementemos esta aplicación lógica y probémosla.

Validación e implementación de la plantilla

Para implementar el recurso de la aplicación lógica, usaremos el comando az deployment group create porque estamos haciendo la implementación en un grupo de recursos. Al implementar con este comando, elige implementar una plantilla remota mediante la especificación de su ubicación con el parámetro --template-uri. En nuestro caso, queremos implementar la plantilla que tenemos localmente, por lo que estableceremos el parámetro --template-file.

1. En Cloud Shell, ejecute az deployment group validate para validar la plantilla:

   az deployment group validate \
   --resource-group "<rgn>[sandbox resource group name]</rgn>" \
   --template-file basic-template.json
   

   El argumento --template-file apunta a la plantilla local. El nombre de archivo de la plantilla es basic-template.json.

   Vemos un enorme bloque de JSON como salida, lo que indica que la plantilla ha superado la validación.

   Azure Resource Manager rellena los parámetros de plantilla y comprueba si esta se ejecutaría correctamente en la suscripción.

   Si la validación genera errores, veríamos una descripción detallada del error en la salida.

2. Ejecute el comando az deployment group create siguiente en Cloud Shell para implementar el recurso de la aplicación lógica definida por la plantilla básica en el grupo de recursos de espacio aislado:

   az deployment group create \
   --name MyDeployment \
   --resource-group "<rgn>[sandbox resource group name]</rgn>" \
   --template-file basic-template.json
   

   Este comando recuerda al comando anterior, pero incluye también el argumento --name para asignar un nombre a la implementación.

   Este comando tarda entre dos y tres minutos en completarse. Cuando la implementación finalice, veremos otro gran bloque de JSON a modo de salida que describe la implementación. Verá provisioningState en el resultado JSON con el valor Succeeded.

Comprobación de la implementación

1. Ejecute az deployment group show para comprobar la implementación:

   az deployment group show \
   --name MyDeployment \
   --resource-group "<rgn>[sandbox resource group name]</rgn>" 
   

   Verá el mismo bloque JSON que vio anteriormente. Podemos ejecutar este comando más adelante si necesitamos estos detalles relativos a la implementación. La salida está estructurada como JSON para que sea más fácil incorporarla a otras herramientas que podemos usar para llevar un seguimiento de las implementaciones y el uso de la nube.

2. Para ver la aplicación en acción, busque el valor logicAppUrl en el resultado JSON. Seleccione la dirección URL o cópiela y péguela en una nueva ventana del explorador. La página muestra el mensaje Hello Azure Logic Apps Template! como se muestra en la captura de pantalla siguiente:

   

¡Enhorabuena! Ha implementado correctamente un flujo de trabajo de la aplicación lógica con una plantilla de Azure Resource Manager.

Tal como mencionamos en este ejercicio, la plantilla básica tiene muchos valores codificados de forma rígida. Estos valores hacen que la plantilla sea menos flexible que lo que nos gustaría. Podemos mejorar la situación mediante parámetros.