Compatibilizar sistemas con los conectores de integración de Azure Logic Apps | return(GiS);

7 min readFeb 9, 2020

Últimamente parece que varios de mis clientes se han puesto de acuerdo en buscar soluciones a una de las tareas más tediosa y aburrida de todas : la integración de aplicaciones que hablan en formatos distintos y/o con mensajes con una composición diferente a la original. Quizás ya hayas oído hablar de Logic Apps, aunque muchas de las demostraciones en las que nos quedamos muchas veces es en la captura de un nuevo tweet, la lectura de una cuenta de correo, etcétera, cuando este servicio da mucho más de sí para escenarios muchos más complejos. Hoy te quiero hablar de cómo integrar diferentes sistemas gracias a Logic Apps.

¿Qué es Logic Apps?

Este servicio está pensado para generar flujos y procesos de una manera sencilla y gráfica. Para ello, el propio servicio pone a tu disposición diferentes tipos de conectores que nos facilita el trabajo de integración:

Conectores manejados: son aquellos listos para usar. La configuración es mínima y no requiere de ningún entendimiento por nuestra parte de cómo se comunica dicho conector con la fuente. Ejemplos de este tipo son la conexión con Twitter, SharePoint, Dropbox, Azure Storage, etcétera.
Conectores para conexión con recursos en local: Azure Logic Apps no solo se limita a la comunicación entre servicios que están públicamente expuestos, sino que también es posible conectarse con aquellos que están on-premises, como puede ser una base de datos Oracle, un SQL Server, Biztalk Server, Teradata, etcétera. Para poder utilizar este tipo de conectores es necesario instalar un componente llamado data gateway.
Conectores de integración: Estos son de los que quiero hablar en este artículo y son aquellos que nos van a permitir crear soluciones B2B (Business to Business). Para poder hacer uso de los mismos es necesario el uso de un recurso llamado Integration Account que te explicaré a continuación.

Conectores de Integración

Como comentaba al inicio de este artículo, este es un escenario que me están pidiendo cada vez más debido a lo sencillo que resulta con Azure Logic Apps. Para verlo con un ejemplo, voy a utilizar un escenario común que me han preguntado más de una vez: cómo podemos devolver de un entorno legacy que devuelve una respuesta en XML, con un formato arcaico, una respuesta JSON con una composición mucho más acorde al 2020 😀 Para este tipo de escenarios los conectores de integración son perfectos, ya que nos permiten no solo devolver la respuesta en un formato diferente sino que podemos alterar el contenido para ajustarlo a las nuevas necesidades. Te muestro paso a paso cómo conseguirlo.

XML del que partimos

Si me conoces un poco, sabes que lo mío son los ejemplos 🙂 Suponte que el XML que recibimos de un sistema legacy es el siguiente:

<?xml version="1.0"?>
<catalog>
    <book id="bk101">
        <author>Gambardella, Matthew</author>
        <title>XML Developer's Guide</title>
        <genre>Computer</genre>
        <price>44.95</price>
        <publish_date>2000-10-01</publish_date>
        <description>An in-depth look at creating applications
      with XML.</description>
        <codes>
            <ISBN>0072224576</ISBN>
            <ISBN13>9780072224573</ISBN13>
        </codes>
    </book>
    <book id="bk102">
        <author>Ralls, Kim</author>
        <title>Midnight Rain</title>
        <genre>Fantasy</genre>
        <price>5.95</price>
        <publish_date>2000-12-16</publish_date>
        <description>A former architect battles corporate zombies,
      an evil sorceress, and her own childhood to become queen
      of the world.</description>
        <codes>
            <ISBN>1410742431</ISBN>
            <ISBN13>9781410742438</ISBN13>
        </codes>
    </book>
</catalog>

Como ves, este se trata de un catalogo de libros, el cual tiene atributos y luego diferentes hijos con diferentes niveles, para ver una casuística más o menos real.

El JSON que esperamos

El objetivo de esta integración, como te decía, no es solo pasar lo mismo que tenemos en ese XML a JSON sino que además queremos alterar el contenido que viene en el mismo, obteniendo un resultado similar al siguiente:

[
    {
        "id": "bk101",
        "title": "XML Developer's Guide",
        "description": "An in-depth look at creating applications with XML.",
        "publishedDate": "2000-10-01",
        "authors": [
            "Gambardella, Matthew"
        ],
        "genre": "Computer",
        "price": "44.95",
        "codes": [
            {
                "type": "ISBN",
                "code": "0072224576"
            },
            {
                "type": "ISBN13",
                "code": "9780072224573"
            }
        ]
    },
    {
        "id": "bk102",
        "title": "Midnight Rain",
        "description": "A former architect battles corporate zombies, an evil sorceress, and her own childhood to become queen of the world.",
        "publishedDate": "2000-12-16",
        "authors": [
            "Ralls, Kim"
        ],
        "genre": "Fantasy",
        "price": "5.95",
        "codes": [
            {
                "type": "ISBN",
                "code": "1410742431"
            },
            {
                "type": "ISBN13",
                "code": "9781410742438"
            }
        ]
    }
]

Vamos a ver paso a paso cómo llegar a este resultado.

Crear una Integration Account

Para poder utilizar este tipo de conectores lo primero que necesitas es un servicio de Microsoft Azure llamado Integration Account. Puedes crearlo de la misma forma que el resto, a través del portal utilizando el botón Create a resource.

Haz clic en el botón Create y elige una suscripción, un grupo de recursos (en mi caso he creado uno nuevo llamado Books-Integration-With-Logic-Apps), una región y un pricing tier (en mi caso he elegido el Basic porque ya he agotado los Free :)). Si todo está correcto tan solo tendrás que esperar unos segundos para tener listo el nuevo recurso.

Este tipo de recursos está compuesto de diferentes componentes:

Para este artículo solo vamos a utilizar el segundo de todos ellos, Maps, pero, como ves, existen otros tipos para otros escenarios de integración. Tienes más información aquí.

Maps

Para las transformaciones de XML a JSON este servicio te permite el uso de plantillas Liquid, creadas por Shopify, que te ayudan a definir cómo será el JSON de salida en base al contenido que recibimos. En nuestro ejemplo he creado una plantilla llamada XmlToJsonTemplate.liquid con este contenido:

[
{% JSONArrayFor item in content -%}{
      "id": "{{item.id}}",
      "title": "{{item.title}}",
      "description": "{{item.description}}",
      "publishedDate": "{{item.publish_date}}",
      "authors": [
            "{{item.author}}"
      ],
      "genre": "{{item.genre}}",
      "price": "{{item.price}}"
      "codes": [
            {
                  "type" : "ISBN",
                  "code": "{{item.codes.ISBN}}"
            },
            {
                  "type" : "ISBN13",
                  "code": "{{item.codes.ISBN13}}"
            }
      ]
}{% endJSONArrayFor -%}
]

Estas se suben en el apartado Maps de tu cuenta de integración, especificando el tipo Liquid y añadiéndole un nombre que no tiene por qué coincidir con el del archivo:

Crear una Logic App y asociarla a tu Integration Account

Ahora que ya tienes al menos una plantilla, el siguiente paso es crear una Logic App que la utilice. Crea una Logic App en el mismo grupo de recursos donde creaste la Integration Account.

Cuando finalice el proceso, en el apartado Workflow Settings asocia ambos recursos:

Ahora, en el diseñador de la Logic App el flujo que utilizo inicialmente para probar la transformación es el siguiente:

Como ves, tiene únicamente tres conectores:

When a HTTP request is received me permite llamar a una URL con el XML que quiero transformar a JSON.
Liquid — Transform XML to JSON es el conector que necesita tener configurado, a nivel de Logic App, la Integration Account. Aquí es donde tienes que elegir que Map se va a utilizar (en este caso el subido anteriormente con el nombre XMLToJSON) y cuál es el contenido a procesar, que en este caso viene del conector anterior (Body).
Response lo utilizo para que nos devuelva el resultado en la herramienta que utilicemos para hacer la llamada.

Probando la transfomación con Postman

Para comprobar el resultado de la transformación voy a utilizar Postman, donde voy a usar la URL proporcionada por el primer conector, el método POST y como cuerpo el XML origen que te mostré al inicio del artículo. El resultado será como el que sigue:

Parece que todo ha salido correctamente, excepto el id que aparece en blanco en ambos libros. Si revisas el XML de ejemplo este valor no viene como un hijo del elemento book sino como un atributo del mismo. Como es un caso habitual, quería que lo vieras ya que ante esta situación necesitaríamos un paso adicional antes de que Liquid convierta nuestro XML a JSON de manera correcta (este no soporta atributos). Para arreglarlo, vamos a crear un archivo llamado XMLNormalizeBook.xslt con esta transformación:

<xsl:stylesheet
    version="1.0"
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:output omit-xml-declaration="yes" method="xml" version="1.0" />
<xsl:template match="/">
        <catalog>
            <xsl:for-each select="catalog/book">
                <book>
                    <id>
                        <xsl:value-of select="@id" />
                    </id>
                    <author>
                        <xsl:value-of select="author/text()" />
                    </author>
                    <title>
                        <xsl:value-of select="title/text()" />
                    </title>
                    <genre>
                        <xsl:value-of select="genre/text()" />
                    </genre>
                    <price>
                        <xsl:value-of select="price/text()" />
                    </price>
                    <publish_date>
                        <xsl:value-of select="publish_date/text()" />
                    </publish_date>
                    <description>
                        <xsl:value-of select="description/text()" />
                    </description>
                    <codes>
                        <ISBN>
                            <xsl:value-of select="codes/ISBN/text()" />
                        </ISBN>
                        <ISBN13>
                            <xsl:value-of select="codes/ISBN/text()" />
                        </ISBN13>
                    </codes>
                </book>
            </xsl:for-each>
        </catalog>
    </xsl:template>
</xsl:stylesheet>

En tu cuenta de integración sube el archivo en el apartado Maps, indicando esta vez que el formato es XSLT:

Ahora en la Logic App añade un paso previo donde debes elegir como conector Transform XML, contenido el Body del conector anterior y como Map el que acabas de crear: