Introducción

Una de las preocupaciones principales del desarrollador es la complejidad que existe realizar despliegues entre entornos.

En data Factory tenemos la opción de integración continua, en este artículo vamos a:

• • Configurar un repositorio en devops.
  • Configurar una plantilla de despliegue entre entornos de factorías de datos
  • Creación de una release para realizar el despliegue entre entornos.

Requisitos

• • Creación de una factoría de datos en entorno de desarrollo. Esta factoría se debe de configurar con GIT de Azure Devops

• • Creación de una factoría de datos para un entorno productivo. Esta no tiene que estar asociado a ningún control de código, ya que esta se actualizará con Azure Pipelines y bajo una plantilla de Resource Manager para cambiar parámetros, por ejemplo, el de conexión, nombres de bases de datos, etc….
  • Configuración de una versión en Azure Pipelines
  • Almacén de claves de Azure (azure key vault). No es necesario, pero si recomendable.

Una vez tenemos nuestras factorías de datos creadas, uno en un ambiente de desarrollo y otro de producción. Imaginemos que ya tenemos un cambio liberado para desplegar en el entorno productivo (es decir, subido a la rama de desarrollo y también publicado, en nuestro ejemplo, estará en adf_publish), el siguiente paso es crear una nueva versión mediante Azure Pipeline.

En la siguiente imagen se muestran los distintos pasos de un ciclo de entrega continua:

X Edición Executive Máster en BI & Advanced Analytics con Tecnologías Microsoft. Conviértete en un año en un experto en BI con un seguimiento personalizado de los mentores y MVPs de SolidQ y con el nuevo temario del máster en BI & Advanced Analytics , introduciendo Modern Data Warehouse, analítica y visualización avanzada.

¡Empezamos el 18 de febrero! Inscríbete ahora y aprovecha el descuento de 50% en la matrícula y 25% en el precio total que hay disponible hasta finales de diciembre. (Válido para las 10 primeras inscripciones desde en inicio de la oferta) Toda la información aquí.

Azure Pipelines

A continuación, vamos a crear un pipeline para realizar un despliegue entre entornos de Azure Data Factory.

Para ello una vez dentro del proyecto de GIT, nos movemos hacia la siguiente pantalla:

En el siguiente paso, tenemos que añadir el artefacto (Azure Repos GIT) y seleccionamos el proyecto de control de código y el repositorio (en nuestro ejemplo se llama ADF), a continuación, la rama por defecto (en nuestro caso adf_publish):

Una vez añadido, vemos la siguiente imagen:

Vamos a crear varios pasos a la hora de desplegar. Primero debemos de pulsar en Stage1 en “1 job, 0 taks”. Primero damos nombre y a continuación agregamos una tarea al job pulsando sobre el +:

Si es la primera vez con crear la tarea de despliegue sería suficiente, pero sucesivos despliegues sería bueno primero crear una tarea para parar los triggers y deshabilitarlos en el entorno productivo, a continuación, desplegar el data factory y después crear otra tarea para habilitar de nuevo los triggers.

Nosotros nos vamos a centrar en el primer despliegue, para los sucesivos despliegues y poder crear esos scripts en powerShell para los triggers, al final del artículo dejo una lista de referencias en la que explicará el proceso de creación.

Para ellos creamos una nueva tarea de ARM template deployment:

Una vez dentro debemos de completarla de la siguiente forma:

Cuando estemos en el template para el deploy, se debe de seleccionar el template que generar el ADF cuando hacemos una publicación y el template parameters son los parámetros que nosotros podemos modificar para obtener una personalización, que veremos en el siguiente apartado (Creación de parámetros personalizados con la plantilla de Resource Manager).

Una vez rellenado toda esta parte, ya podríamos crear nuestra primera release:

Se puede ver en la siguiente captura:

Para ejecutarlo, debemos de pulsar en deploy:

Y si la ejecución ha sido satisfactoria, aparecerá de la siguiente manera:

Con ésto, tendríamos nuestro despliegue realizado desde el entorno de desarrollo hacia el de producción, con los parámetros de desarrollo, es decir sin mover bases de datos, runtimes, etc…

En la siguiente sección, vamos a ver esta personalización y además crear una librería donde van a estar guardados.

Creación de parámetros personalizados con la plantilla de Resource Manager

Al tener el data factory en git, se crea una fichero llamado arm-template-parameters-definition.json en la carpeta raíz de la rama de Git.

Al publicar los cambios en la rama que tenemos en este ejemplo adf_publish, Data Factory lee el archivo y usará la configuración que esté parametrizada.

En la imagen anterior podemos ver como estamos en la rama master y tenemos la plantilla.

La sintaxis es la siguiente:

• • El establecimiento de un nombre de propiedad en * indica que quiere parametrizar todas las propiedades que incluye (solo en el primer nivel, no de forma recursiva). También puede proporcionar excepciones a esta configuración.
  • El establecimiento del valor de una propiedad como una cadena indica que quiere parametrizar la propiedad. Use el formato <action>:<name>:<stype>.
  • <action> puede ser uno de estos caracteres:
  • = significa que el valor actual debe conservarse como el valor predeterminado para el parámetro.
  • – significa que no se debe conservar el valor predeterminado para el parámetro.
  • | es un caso especial para los secretos de Azure Key Vault para una cadena de conexión o claves.
  • <name> es el nombre del parámetro.
  • <stype> es el tipo del parámetro. Si <stype> está en blanco, el tipo predeterminado es string. Los valores admitidos son: string, bool, number, object y securestring.
  • De forma predeterminada, todas las cadenas seguras, como los secretos de Key Vault, las cadenas de conexión, las claves y los tokens, están parametrizadas.

Ejemplo de una plantilla:

{
    "Microsoft.DataFactory/factories/pipelines": {
        "properties": {
            "activities": [{
                "typeProperties": {
                    "integrationRuntime":{
                        "referenceName": "=::string"
                    },
                    "url": "=::string", 
                    "environmentPath": "=::string",
                    "connectVia": {
                        "referenceName": "=::string"
                    }
                }
            }]
        }
    },
    "Microsoft.DataFactory/factories/integrationRuntimes":{
        "name":"=",
        "properties": {
            "typeProperties": {
                "ssisProperties": {
                    "catalogInfo": {
                        "catalogServerEndpoint": "=",
                        "catalogAdminUserName": "=",
                        "catalogAdminPassword": {
                            "value": "-::secureString"
                        }
                    },
                    "customSetupScriptProperties": {
                        "sasToken": {
                            "value": "-::secureString"
                        }
                    }
                },
                "linkedInfo": {
                    "key": {
                        "value": "-::secureString"
                    },
                    "resourceId": "="
                }
            }
        }
    },
    "Microsoft.DataFactory/factories/triggers": {
        "properties": {
            "pipelines": [{
                    "parameters": {
                        "*": "="
                    }
                },  
                "pipelineReference.referenceName"
            ],
            "pipeline": {
                "parameters": {
                    "*": "="
                }
            },
            "typeProperties": {
                "scope": "="
            }
 
        }
    },
    "Microsoft.DataFactory/factories/linkedServices": {
        "*": {
            "properties": {
                "typeProperties": {
                    "accountName": "=",
                    "username": "=:-username:String",
                    "userName": "=:-userName:String",
                    "accessKeyId": "=",
                    "servicePrincipalId": "=",
                    "userId": "=",
                    "clientId": "=",
                    "clusterUserName": "=",
                    "clusterSshUserName": "=",
                    "hostSubscriptionId": "=",
                    "clusterResourceGroup": "=",
                    "subscriptionId": "=",
                    "resourceGroupName": "=",
                    "tenant": "=",
                    "dataLakeStoreUri": "=",
                    "baseUrl": "=",
                    "database": "=",
                    "serviceEndpoint": "=",
                    "batchUri": "=",
                    "databaseName": "=",
                    "systemNumber": "=",
                    "server": "=",
                    "url":"=",
                    "aadResourceId": "=",
                    "connectionString": "-:-connectionString:string",
                    "existingClusterId": "-"
                },
                "connectVia": {
                    "referenceName": "="
                },
                "dependsOn": "="
            }
        },
        "Odbc": {
            "properties": {
                "typeProperties": {
                    "userName": "=",
                    "connectionString": {
                        "secretName": "="
                    }
                }
            }
        }
    },
    "Microsoft.DataFactory/factories/datasets": {
        "*": {
            "properties": {
                "typeProperties": {
                    "folderPath": "=",
                    "fileName": "="
                }
            }
        }}
}

En la siguiente imagen nos ponemos en la rama adf_publish y tenemos el fichero creado a partir de la plantilla: ARMTemplateParametersForFactory.json

Este fichero es el que hemos utilizado para el despliegue desde desarrollo a producción. Contiene generalmente cadenas de conexiones, password y cualquier otro elemento que hemos decidido parametrizar.

Un pequeño extracto del fichero:

Este fichero podemos cambiar los valores a la hora de desplegar.

Para ellos debemos de volver otra vez a Pipilines y entrar en la opción Library:

A continuación, podemos crear un nuevo grupo de variables, por ejemplo, a partir del extracto de arriba podemos crear el siguiente mapeo:

A continuación, podemos hacer un mapeo en la tarea de despliegue del ARM:

Para ello el valor será el que hemos dado en la librería o podemos hacer que sea un parámetro de la librería, porque si cambia no tenemos que venir aquí a editar el valor. Tenemos que ponerle el símbolo del $ delante y entre paréntesis el nombre de la variable.

Referencias

https://docs.microsoft.com/es-es/azure/data-factory/source-control

https://azure.microsoft.com/es-es/services/key-vault/

https://docs.microsoft.com/es-es/azure/data-factory/continuous-integration-deployment

X Edición Executive Máster en BI & Advanced Analytics con Tecnologías Microsoft. Conviértete en un año en un experto en BI con un seguimiento personalizado de los mentores y MVPs de SolidQ y con el nuevo temario del máster en BI & Advanced Analytics , introduciendo Modern Data Warehouse, analítica y visualización avanzada.

¡Empezamos el 18 de febrero! Inscríbete ahora y aprovecha el descuento de 50% en la matrícula y 25% en el precio total que hay disponible hasta finales de diciembre. (Válido para las 10 primeras inscripciones desde en inicio de la oferta) Toda la información aquí.