Tutorial Talend Open Studio. # 8 Jobs De Gestión masiva De Ficheros.
En este tutorial vamos a ver como diseñar un proceso de carga masiva de ficheros a partir de un conjunto de archivos de hoja de cálculo que se depositan en una determinada carpeta.
Tenemos dos opciones de diseño del job:
Que el job esté siempre en ejecución esperando a que se introduzca el fichero en la carpeta para arrancar el proceso.
Que el job se ejecute periódicamente de manera programada.
Para la primera opción utilizaremos un componente de la famila «wait for» (tWaitForFile,tWaitForSocket, tWaitForSqlData) estos componentes están permanentemente escuchando cada período que les indiquemos, para comprobar que se dé un determinado suceso. En nuestro ejemplo, utlizaremos tWaitForFile dado que estamos esperando la entrada de ficheros a un directorio.
Lo configuramos indicando el directorio que debe escanear, el tiempo en segundos de cada iteración y si queremos que solo detecte un tipo de fichero, podemos usar la mascara de la opción file mask. mediante el uso del caracter * podemos por ejemplo filtrar que nos saque ficheros csv («*.csv) o de excel («*.xls*» ).
Al arrancar el job vemos que el proceso queda latente hasta que dejamos un fichero que cumple las condiciones en el directorio.
En ambos diseños de proceso necesitamos un componente que nos liste todos los ficheros que hay en la carpeta. Esta lista de ficheros nos lo genera el componente tFileList que lo podemos conectar con el flujo iterate del componente tWaitForFile.
La configuración del tFilelist no difiere demasiado del tWaitForFile:
Primero indicamos el directorio en donde encontramos los ficheros. También le confirmamos si queremos que nos liste archivos o directorios (carpetas). Generar error si no encuentra nada. Máscara de entrada de ficheros, con la posibilidad de utilizar expresiones regulares
Ahora lo siguiente es incorporar un fichero de imput que lea los ficheros. En nuestro ejemplo utilizaremos tFileImputExcel y le indicaremos en el campo File Name la variable del componente tFileList «CURRENT_FILEPATH» la manera más rápida de encontrar la variable como vimos en el tutorial 6 es empezar a escribir tFile + CRTL+SPACE.
Con un resultado final ((String)globalMap.get(«tFileList_1_CURRENT_FILEPATH»))
Para poder leer todos los datos de los diferentes ficheros, tenemos que cambiar el flujo a iterate como también vimos en el tutorial 6. Para ello utilizamos el componente tFlowToIterate ya que necesitamos que los registros estén cargados uno a uno en las variables.
El siguiente paso es volver a unir los flujos iterate en un flujo main. Esto lo hacemos mediante el componente tIterateTo Flow
Para ello copiamos el esquema y mapeamos en el apartado mapping los campos del esquema con las variables que nos genera el componente anterior de tFlowToIterate.
En el ejemplo anterior vemos como se mapean a las columnas contenidas en el esquema las diferentes columnas del imput Excel que viene por el flujo Row1 con los campos de los ficheros Excel. Y también en la columna «SegundaCol» el nombre del fichero que se obtiene directamente del componente tFileList.
Tutorial Talend Open Studio. # 7 Componentes De Transformación De Datos
Componentes de generación de datos para probar desarrollos.
tRowGenerator: Generar datos automáticamente
Para desarrollar los procesos, es muy útil disponer de ciertos datos para hacer pruebas de laboratorio en un entorno controlado, para esa tarea Talend nos ofrece unos componentes para generar datos de manera automática y aleatoria del numero de registros que nos hagan falta, desde nombre de personas, correos electrónicos ciudades, cadenas de textos, números, etc…
También mediante la opción parameters podemos limitar la longitud de los campos generados. Por ejemplo. «Length_>6»
tFixedFlowImput: Generar datos manualmente
Este componente permite generar una tabla de datos en la que podemos introducir datos de manera manual.
Lo primero es con el botón «Edit Schema» es generar el esquema que necesitemos para nuestra tabla de datos.
Y luego la forma más cómoda de introducir datos es usar la opción «Use Inline table» para ir introduciendo lo datos por columnas.
Componentes de separación y generación de múltiples flujos de datos
Hasta ahora en publicaciones anteriores, únicamente hemos visto jobs que trabajan con un único flujo de datos. Pero es posible separar un flujo en múltiples datos así como juntar diferentes flujos en uno único.
Componentes de filtro y separación de flujos
tFilterRow: Filtro de datos
Este componente nos permite filtrar unos datos a partir de una o varias condiciones en las que podemos seleccionar el tipo de condición AND/OR. Este componente nos ofrece dos flujos de salida:
El flujo de salida «Filter», es decir, el flujo que contiene los datos que cumplen la condición.
El flujo de salida»Reject», el flujo rechazado que no cumple la condición
El ejemplo de la imagen, se muestra la configuración del filtro del componente y los dos tipos de flujo de salida del componente tFilterRow.
tSchemaComplianceCheck: Comprobación de los registros que cumplen el esquema que queremos utilizar.
Este componente es el más usado para «data quality». Es muy útil porque algunas veces nos encontramos en errores en el proceso debido a que determinados registros no cumplen el «data type» del esquema. Con este componente podemos detectar y separar los registros que no cumplen el esquema para solucionar la incidencia.
Este componente es de hecho un filtro pero con un criterio especial de filtro que es cumplir el esquema que indicamos.
El componente lo podemos configurar para este fin de dos maneras:
Custom defined: Cuando manualmente indicamos las columnas y datatype que queremos analizar.
Use another schema for compliance check: En esta opción podemos copiar el esquema actual y hacer los cambios que necesitamos y hacer pasar un check por todo el esquema, pero teniendo en cuenta que hay que mantener el mismo orden de los campos.
El subjob de la imagen muestra un ejemplo en el que vemos que el componente tiene dos salidas: La salida main con los registros correctos que cumplen el esquema y un flujo de rejects con los registros que no cumplen el esquema.
En el ejemplo creamos manualmente una tabla con una sola columna de tipo string y introducimos los siguientes registros:
«1»,»dos»,»3″,»4″ y le indicamos en la configuración del componente que la columna es de tipo «integer». En el flujo main nos desviará los registros que pude convertir a int, es decir 1,3,4 y en el flujo de rechazo el segundo registro con valor «dos» debido a que es un string que no puede convertir en número entero (Integer).
tReplicate: Replicar el flujo.
Este componente es utilizado cuando por motivo de proceso necesitamos que el flujo se replique, por ejemplo para hacer una misma salida de datos a una tabla de una base de datos y también a un fichero. O por ejemplo si necesitamos dos flujos, uno con todos sus registros para hacer una salida y la suma o valores agregados con la finalidad de realizar comprobaciones, etc…
Componentes de Unión de flujos
tUnite: Unir dos flujos
Este componente hace lo contrario al tReplicate, ya que une dos flujos de datos que tengan un mismo esquema, pero con alguna restricción, ya que no podemos unir un flujo que haya sido separado en el mismo subjob.
No combina registros, sino que simplemente junta un flujo de datos debajo del otro, tipo UNION de SQL.
tJoin: Join de flujos.
Lo cierto es que después de la potencia y optimización de proceso y otras capacidades que nos permite el componente tMap, tJoin queda bastante canivalizado por el todo poderoso componente tMap y su uso es menor.
Para configurar el componente primero debemos indicar cual es el flujo de principal. (Por ejemplo el que trae el flujo de ventas que trae las claves foráneas de cliente y de producto). Por otra parte hay que identificar el flujo de lookup (que puede ser por ejemplo la tabla de clientes y productos cuyas claves primarias se unen a las foráneas del flujo principal, para mostrar el nombre de clientes y de los productos que no aparecen en la tabla ventas).
Luego en la pestaña de configuración del componente tJoin, únicamente debemos indicar las claves de unión de los dos flujos, sea única de un campo o doble o de más de un campo. Así como los campos de la tabla de lookup que queremos mantener en el flujo de salida. Hay que tener en cuenta que los campos del flujo main se mantienen todos, dado que no es modificable su incorporación.
tMap: Un comodín que une con join, filtra y genera expresiones
Es una joya de Talend, la verdad es que de manera muy intuitiva conecta cualquier número de flujos de entrada y genera cualquier número de flujos de salida. El tMap, tiene un asistente gráfico que permite una configuración muy sencilla.
Como en el caso anterior del tJoin lo primero de todo es identificar que flujo es el principal.El flujo principal o main, que se nos muestra en el job con línea continua, ha de ser la tabla de hechos o con las medidas o métricas además de incorporar alguna clave que nos permita conectar con alguna de las otras tablas que vienen de los flujos de lookup. Los Flujos de lookup se conectaran al componente de tMap con flujo discontínuo.
Una vez conectados los flujos, configuramos el componente. En los paneles de la izquierda de la pantalla de configuración de tMap, encontramos los imputs de datos sobre estos imputs debemos relacionar las claves. Estas relaciones las establecemos simplemente «drag and drop», es decir arrastrando el campo de la clave foránea del flujo main a la clave primaria de un flujo de lookup, tras lo cual observamos que los campos relacionados de cada tabla quedaran conectados mediante una línea de un color violeta. También nos aparecerán unas llaves sobre los campos clave de las tablas de lookup de color azul que indican la relación definida en esas claves.
Con el botón de configuración, representado por la llave inglesa, en cada flujo imput, podemos configurar el tipo de unión de cada flujo con el flujo main, puede ser de tipo «left outer», o «inner» es decir en «inner» no se incorporan los registros no coincidentes y el el «left outer» se mantienen todos los registros con clave de unión «null».
Después de crear las relaciones, ya podemos generar las tablas de salida de datos, que podemos generar los que necesitemos, creando los mismos con el «+» de la parte superior del panel derecho. Así nos devuelve este componente de 1 a n salidas «output».
Los campos de cada flujo de salida los podemos arrastrar de los flujos de origen, vemos que se nos generan unas líneas de relación entre los campos de los flujos de entrada y salida. Si seleccionamos un flujo, estas relaciones las vemos en amarillo y el campo de la tabla de origen lo vemos de color verde y si no está seleccionado la relación la vemos de color gris.
Pero eso no es todo también podemos filtrar los datos y esto lo podemos hacer mediante el segundo botón de flecha y +. Una vez le damos al botón se nos abre un espacio para introducir la condición que la podemos escribir de manera asistida abriendo el editor pulsando el botón de la derecha de los tres puntos. Una vez introducida la condición (en el ejemplo filtramos la «zona_1») vemos que se nos establece una relación de color naranja con los campos implicados en la condición.
Importante indicar que en la condición de la expresión del tMap: Si el campo es numérico usaríamos el operador «==», es decir, por ejemplo row2.zona==1. Pero si es string utilizaremos la función equals, es decir row2.zona.equals(«Zona_1»), tal como muestra la imagen anterior. También podemos crear una nueva salida de los registros rechazados con la expresión anterior creando otra salida de output, con el mismo esquema de columnas y en el botón de configuración del output de la llave inglesa marcar «Catch output reject -> True». De forma similar también podemos obtener registros rechazados por el tipo de unión inner indicando de igual manera»Catch lookup inner join reject->»
Pero aquí no se acaba la cosa, no señor… desde el tMap podemos hacer más cosas, como por ejemplo generar nuevos campos con expresiones.
¿Cómo generar campos con expresiones en tMap? Pues lo primero que necesitamos es generar en el esquema de salida nuevos campos mediante la tecla «+» y configurar el tipo de datos que precisamos.
Podemos como ejemplo generar 3 campos nuevos que nos puden ser útiles:
Una columna con un valor fijo constante
Una fórmula que nos calcule el precio medio (Ventas / Unidades)
Una tercera columna de time stamp, que nos marque la fecha y hora de creación del registro
Otra columna de clave primaria del flujo de salida, es decir una columna con la secuencia numérica que podamos utilizar como clave primaria de una tabla de datos
Una vez creados los 3 nuevos campos en el esquema ya podemos generat la expresión, que en nuestro caso será con la ayuda del botón de los 3 puntos que nos abre el asistente de expresiones.
La primera columna es muy sencilla de crear pues simplemente debemos indicar el valor de la constante incorporamos en el campo (en el ejemplo una constante de valor int 1).
La segunda si utilizamos el asistente es muy sencillo, arrastramos o doble clic en los cuadros de los campos que necesitamos en nuestra expresión al cuadro de expresiones utilizando los botones de las operaciones que necesitemos:
Arrastramos el campo row1.ventas, pulsamos el botón del operador división / y arrastramos el campo row1.unidades, quedando la expresión como en la imagen siguiente
Para la tercera columna de crear una columna que nos indique el sello de tiempo utilizaremos las funciones que nos ofrece el asistente. Buscamos en la categoría de funciones TalendDate y elegimos la función getDate. Al seleccionar nos aparece en la pantalla de expresión la función con un patrón de fecha-hora.
De igual manera actuamos para obtener la columna con la secuencia numérica. Seleccionamos la categoría «Numeric» y seleccionamos la función «Sequence». «S1» es el contador de la numeración, si queremos tener más de un contador que no siga la misma numeración tenemos que crear otro contador, por ejemplo «S2»
Podemos utilizar así una gran variedad de funciones predefinidas para generar expresiones que podemos incorporar en campos de salida.
Pero la potencia del tMap no acaba ahí podemos aún hacer más cosas, como por ejemplo crear y utilizar variables globales que podemos utilizar tanto dentro como fuera del componente tMap,
¿Cómo crear y asignar variables a campos mediante tMap?
En el cuerpo central de configuración del tMap es donde podemos crear expresiones que podemos guardar en variables para ser utilizadas en expresiones de campos generados de los outputs o incluso creando directamente nuevos campos arrastrando la variable al output. En el ejemplo siguiente, creamos una variable llamada Var1 mediante una expresión que concatenamos dos campos de dos imputs de datos mediante el + y le añadimos un espacio » » entre medio de los campos.
Componentes para «data quality».
Este grupo de componentes, se utilizan para transformar los datos para cumplir los requisitos de un esquema. Estos componentes están muy relacionados con el componente que vimos en el grupo de fitros que era el tSchemaComplianceCheck que nos separaba en un flujo diferente al principal aquellos registros que incumplían los requisitos del esquema.
En el ejemplo que se utilizó, separaba el registro «dos» debido que es un dato de cadena de texto » string» que no cumplía el ser un número entero «integer».
Lo que podemos hacer es cambiar el registro con «dos» por otro con «2». Esto lo podemos hacer con el componente tReplace.
El componente tReplace permite buscar una cadena de texto y substituirla por otra. Le podemos indicar si substituye toda la palabra si es «case sensitive» es decir si discrimina o no Mayúscula/minúscula. También tenemos la opción en Advanced mode en utilizar expresiones regulares.
En el ejemplo le indicamos que busque «dos» y lo substituya por «2», con lo que una vez sustituido, tenemos ya todos los datos numéricos que podemos convertir de string a int. Esta conversión la podemos hacer con el componente tConvertType.
El componente tConvertType nos permite establecer un esquema y mediante la opción «Autocast» convertir los tipos de origen al «datatype» establecido en el esquema. También si no queremos convertir todo el esquema, podemos hacerlo manualmente de algunas columnas mediante la opción «Manual Cast».
El ejemplo muestra como el componente de tSchemaComplianceCheck rechaza los registros que no cumplen. El componente tReplace substituye los valores para que cumpla («dos» por «2». Por último el componente tConvertType, cambia el datatype (En el ejemplo de «string» a «integer».)
El componente tFilterColumns, nos ayuda a eliminar las columnas del esquema que no sean necesarias, simplemente modificando el esquema.
Otros componentes de transformación
Componente tAggregate: Nos permite agregar registros a partir de uno o varios campos y unas funciones de agregación de forma idéntica al «group by» SQL. En la parte superior indicamos los campos que queremos agregar y en la inferior los campos con las funciones de agregación.
Tutorial Talend Open Studio. # 6 Variables globales y de Contexto.
En Talend encontramos dos tipos de variables: Variables de contexto y Variables de tipo global.
Variables de contexto: Són variables que las utilizamos como parámetros predefinidos que nos permiten diseñar varios escenarios. Estos distintos escenarios en Talend se denominan contextos. Los contextos son ciertamente muy útiles, ya que nos permiten ejecutar un mismo job con diferentes parámetros.
Estas variables de contexto que nos permiten ejecutar un mismo job con diferentes parámetros preestablecidos , las podemos guardar en el repositorio para ser reutilizadas en diferentes jobs.
Variables globales: A diferencia de las anteriores, estas variables no las predefinimos como parámetros fijos, sino se generan y utilizan dentro del proceso de un job.
Variables de contexto
¿Qué es un contexto en Talend? Podemos entender un contexto como un conjunto de parámetros que nos definen un escenario de ejecución del subjob.
Quizás el caso más utilizado de contexto sea el de la conexión a una base de datos. Podemos utilizar distintos contextos dentro del mismo job, por ejemplo para ejecutar el proceso en unos casos en entorno de desarrollo y en otros de producción. Simplemente cambiando de contexto muy útil. Pero podemos utilizar contextos para muchas otras cosas, como por ejemplo que se ejecute el job para un determinado año o con un determinado filtro etc..
¿Cómo generamos un contexto?
La fórmula no difiere en absoluto a la de creación de otros elementos en el repositorio de Talend. Un contexto en el repositorio nos permite disponer de un conjunto de parámetros que pueden ser reutilizados. También podemos generar contextos desde el propio componente del job.
¿Como generar contextos en el repositorio?
Pues ya casi lo hemos visto en tutoriales anteriores, pus no difiere demasiado de la creación de los otros elementos del repositorio, es decir: Botón derecho en el nodo de «Contexts» y luego «Create Context Group». Como en cualquier otro elemento del repositorio, le damos nombre, propósito, descripción, versión y status y se nos abre una tabla en la que podemos añadir dos tipos de datos:
Contextos: Son los escenarios globales que definimos. Por defecto existe un contexto llamado «Default» que lo podemos usar junto a tantos otros que podemos ir creando.
Variables de contextos: En cada uno de los contextos que disponemos podemos dar distintos valores a cada una de las variables, las cuales, una vez definidas en el repositorio, són comunes para todos los contextos.
No es necesario que en todos los contextos tengan valor todas las mismas variables.
Para crear un nuevo contexto , clic en el signo + del vértice superior derecho que la tabla. Tal como muestra la imagen anterior se nos abre una ventana, clic en «New» damos un nombre al contexto.
Una vez creado el contexto tenemos una tabla que nos permite introducir distintos valores de las variables en la columna Default como en la que hemos llamado New_context.
Para crear nuevas variables, clic en el signo + que encontramos en el vértice inferior izquierda de la tabla. Si queremos eliminar alguna variable lo podemos hacer con el aspa roja.
¿Cómo incorporar contextos en un job?
Tenemos dos opciones. La primera opción es a partir del botón de contexto de la parte inferior izquierda del panel. En este caso podemos seleccionar las variables y contextos que tengamos guardados en el repositorio de contextos.
La segunda opción es entrar los contextos y las variables manualmente con los botones + de manera idéntica al proceso explicado en la creación de contextos del repositorio.
En el desplegable «Default context environtment» podemos seleccionar uno de los contextos que hemos creado, así el job se ejecutará con los valores de las variables correspondientes al contexto que hayamos seleccionado.
¿Cómo incorporar las variables de contexto para que tengan efecto?
Podemos incorporar el valor de las variables a cualquier campo de configuración de los componentes de una manera muy sencilla. Pulsando crtl+space se despliegan todas las variables que hay en el sistema. Como la lista es larga, vamos más directos si escribimos «context.» y luego crt+ space. Así solo nos mostrará las variables de contexto como muestra la imagen siguiente de la izquierda.
Por otra parte también podemos recuperar la variable de contexto dentro de una query o en el texto de un correo electrónico mediante el mismo procedimiento pero encerrando la variable entre «+..+» En la imagen de la derecha se muestra como ejemplo, como se incorpora la variable de contexto en la clausula WHERE de la query de un componente de imput de Base de Datos.
La variable quedará incorporada al campo y se recuperará cuando se ejecute el job, según sea el valor que le corresponda a ese contexto.
Variables globales
A diferencia de las variables de contexto que funcionan como parámetros pre-establecidos, las variables globales se generan y utilizan de forma dinámica dentro de un proceso de un job.
¿Cómo podemos obtener variables globales?
Para generar las variables podemos utilizar dos componentes totalmente diferentes, pero con resultados similares:
1. Mediante el componente tFlowToIterate
2. Mediante el componente tSetGlobalVariables
¿Cómo Funciona tFlowToIterate?
Este componente cambia el tipo de flujo de tipo «main» a tipo «iterate». Es decir,nos cambia el tipo de flujo de manera que en vez de enviar el caudal de datos a «chorro» lo frena y lo entrega registro a registro. Esto permite a partir de ese momento recuperar el dato de cada uno de los registros en variables. Las variables generadas así, estarán identificadas por el nombre del componente, seguido de un punto y luego el nombre del campo.
Para poder explicar mejor el funcionamientos hemos preparado un ejemplo:
A partir de una tabla en donde tenemos registros con el nombre y el correo electrónico por ejemplo de clientes, queremos enviar un correo electrónico a cada uno de los clientes de la tabla.
Pues tal como muestra la imagen siguiente, a partir de un imput de datos, el componente tFlowToIterate nos cambia el flujo de datos a iterate, por lo que podemos recuperar las variables en el componente de enviar correos electrónicos de talend que es tSendMail.
En la configuración del componente de envio de correo, en el campo «To» empezamos a escribir el nombre del componente que genera la variable mediante el flujo iterate. Como hemos visto el nombre del componente es tFlowToIterate, por ejemplo para filtrar variables empezamos a escribir tflow y CRTL+SPACE, y se nos muestra la lista de varibles filtradas que dependen de ese componente, así encontramos facilmente la variable tFlowToIterate.mail que contiene tras el nombre del componente y un punto, el nombre del campo de la tabla a incorporar, como muestra la imagen siguiente:
Una vez seleccionada la variable veremos que en el campo no nos refleja el nombre de la variable sino de la siguiente expresión java:
((String)globalMap.get(«row1.mail»))
Que recupera el valor de la variable del campo mail que circula por el flujo row1 del job.
¿Cómo funciona tSetGlobalVariables?
Pues de forma similar pero incluyendo manualmente las claves de cada campo de la siguiente manera:
En el campo variables hacemos clic en el + y vamos añadiendo los nombres de las variables que en este caso son Key_name y key_mail y como valor el nombre del flujo que en este caso es row1, un punto y el nombre del campo, es decir:
row1.name y row1.mail.
El proceso es un poco más manual. El resultado es que cargamos de datos las variables que hemos llamado: Key_name y Key_mail
Ante cualquier necesidad de soporte o formación adicional proyectos, contactar con nosotros o comprar un paquete de soporte o formación en nuestra tienda on-line.
Tutorial Talend Open Studio. # 5 Organización Jobs de Bases de datos
Organizar la ejecución vinculando subjobs con triggers
Cuando incorporamos diferentes subjobs dentro de un job como se muestra en el tutorial anterior. Un elemento fundamental a tener en cuenta en el diseño de nuestros procesos, es que la ejecución de los mismos siga un orden.
Lo primero que tenemos que tener claro es que la ejecución de los jobs no sigue el orden estricto en el que están situados en el lienzo el Job. Ni esperan a ejecutarse a que finalice el anterior, por lo que muy posiblemente ocurrirá si nuestros subjobs no se ejectutan siguiendo un orden, que el resultado del proceso no sea el adecuado. Las variables o conjunto de datos que generamos en un subjob para utilizar en el otro estarán incompletos y viciando el resultado del proceso.
Para asegurarnos que que el orden de ejecución sea el correcto la solución es subordinar los jobs con «triggers» (disparadores). Como nos muestrala imagen siguiente, el primer job se convierte en subjob principal de ambos subjobs. El subjob segundo pierde el color verde del componente principal (sólo se mantiene en verde el componente principal del primer subjob). Esto ocurre porque el segundo subjob está conectado mediante un trigger de tipo «Subjob Ok , por lo que el segundo subjob esperará a que el primer subjob finalice y solo arrancará si el primer subjob finaliza con éxito. Esto asegura que la ejecución del job sea el adecuado!.
Si trabajamos de esta manera organizando la ejecución de los subjobs, ya estamos solucionamos la mayoría de los problemas potenciales.
Pero aún no es el mejor diseño, debido a que en este caso que trabajamos con imputs y outputs de base de datos. Cada subjob se ejecuta dentro de una transacción SQL. Esto genera que tengamos abiertas conexiones y diferentes transacciones con colas de ejecución de las que no disponemos de tanto control y nos pueden perjudicar el rendimiento del proceso.
Gestión de conexiones «PreJob» y «Postjob»
La mejor manera de solucionar el problema de las conexiones múltiples es mediante la gestión centralizada de las conexiones con el componente prejob que nos posibilita abrir las conexiones antes que se ejecute nada del job y luego con el componente postjob cerrar las conexiones una vez se han ejecutado todos los subjobs del Job
Como nos muestra la imagen el componente prejob asegura que primero de todo se ejecuten la cadena de componentes de apertura de conexiones a las bases de datos.
Luego se ejecutan los dos jobs que hemos diseñado y en el caso del segundo subjob que realiza un output a una tabla de base de datos le hemos añadido dos componentes más:
Commit: Confirma la entrada de datos. Por eso le unimos el trigger que el subjob es ok, pues estamos confirmando el proceso únicamente si todo funciona correctamente.
Rollback: Si se produce un error, retrocede los datos que hayan podido entrar, debido a que está conectado a un trigger de subjob error. Así se evita que en la tabla de destino tengamos datos inconsistentes por una entrada incompleta de datos motivada por un error de proceso.
Finalmente cerramos las conexiones con un componente Postjob que mediante una cadena de disparadores (trigger) «On Subjob Ok» cierra las conexiones existentes.
En el tutorial anterior vimos como como trabajar en el repositorio de Talend. Ahora ya podemos introducir el elemento principal de creación de procesos de integración de datos como son los Jobs.
Creación de jobs
Un job de Talend es un proceso que vamos a desarrollar a partir de diferentes componentes conectados mediante flujos de datos y disparadores. La creación de un job vuelve a ser similar a lo que ya hemos tratado en los otros elementos del repositorio. Empezamos con un click en el botón derecho en el nodo de «job design» y posteriormente seleccionamos » Create job» o «Create folder» si en este último caso queremos estructurar los jobs dentro de una carpetas temáticas.
Como siempre informamos del nombre, propósito del job, la descripción, y versión . Disponemos asimismo del campo de status, que mediante una lista desplegable podemos asignar la situación del job (desarrollo,test o producción).
Después de seleccionar finish, se nos abre el lienzo en donde vamos a desarrollar nuestro job a partir de las cajas de componentes y conectores de flujos de datos.
Una buena práctica es mediante una nota, explicar y documentar en el lienzo el proceso que estamos creando. La nota «Note» la encontraremos en la paleta de componentes y la podemos arrastrar al lienzo. La nota se autoajusta al contenido del texto pero la podemos dimensionar y mover para situarla en donde nos parezca mejor.
Incorporar componentes en el job
Existen diferentes formas de incorporar componentes en el job. Una de ellas es buscar el componente directamente en la paleta de componentes que tenemos en el panel de la derecha de nuestro espacio de trabajo. Otra manera como muestra la imagen inferior, es mediante el puntero en el lienzo, empezar a escribir el nombre del componente y nos irá apareciendo la lista de componentes coincidentes
En el caso que necesitemos trabajar con elementos metadata incorporados en el repositorio, la mejor manera de añadir componentes es arrastrar la conexión al lienzo para que nos muestre la lista de los componentes que podemos utilizar para esa conexión. Muy util ! Por ejemplo si lo que necesitamos hacer es un imput de una tabla, lo más práctico y rápido es arrastrar desde el repositorio el esquema de la tabla al lienzo y de esa manera tras seleccionar el componente de imput de la base de dados, prácticamente nos traerá toda la configuración ya realizada.
Subjobs dentro de un Job
Cuando unimos componentes y conexiones formamos diferentes subjobs que identificaremos por estar contenidos en una forma rectangular que los rodean que por defecto es de color azul. Dentro de un subjob disponemos de un componente principal quees de importancia debido a que sólo desde el componente principal podemos disponer de ciertas funcionalidades como es el caso de desactivar el subjob o enviar un disparador de una acción que implique a todo el subjob.
El componente principal si no tiene dependencia subordinada de otros subjobs, nos podemos fijar que está resaltado en color verde.
Preparando un primer subjob
Como primer ejercicio podemos hacer un subjob muy simple, como por ejemplo hacer un imput a partir de una query a una base de datos. Esto lo podemos hacer a partir de un componente de imput de base de datos. Para visualizar el resultado, es necesario añadir un componente que nos va a permitir visualizar la consulta en la ventana de edición, en la pestaña «run» junto al resto del log del proceso.
Una vez incorporados los dos componentes que vamos a utilizar los vamos a unir mediante un flujo de datos de tipo Principal «Main». Un flujo de datos de tipo principal viene a ser como una tubería en donde circulan los datos hasta llegar al siguiente componente. Un flujo se puede conectar entre los dos ports de los dos componentes. Como vemos en el ejemplo, el de consulta de base de datos, tiene un port tipo «o» de output ( aparece cuando acercamos el puntero al lateral), mientras el componente tLogRowel dispone de un port «i» de imput. Conectamos ambos puertos con el puntero estirando la línea del port de origen «o» al de destino «i».
También existe hay otra manera de conectar el flujo Main, seleccionando el componente y botón derecho Row –>Main.
Configuración vista de Edición
La vista de edición que si recordamos corresponde a la vista del panel inferior central de la pantalla, dispone de 4 pestañas:
Job: Que muestra los datos generales del job que hemos introducido-
Contexts: Sirve para incorporar parámetros que se utilizarán como variables de contexto que nos permite establecer diferentes escenarios de ejecución del job.
Component: Esta pestaña nos muestra y permite configurar los diferentes elementos del componente que tengamos seleccionado. Si seleccionamos un componente del lienzo, esta pestaña mostrará los datos de configuración concretos del componente seleccionado. Por otra parte si en vez de seleccionar el componente, seleccionamos el flujo que conecta dos componentes, esta misma pestaña nos mostrará información del esquema de datos. Por último si seleccionamos el subjob, mediante un clic en el área del subjob, podemos configurar elementos del aspecto del subjub, como el color del subjob.
Configuración componente Imput base de datos
Como muestra la imagen inferior, la configuración corresponde básicamente a configurar la conexión a la base de datos.
En el apartado del esquema y query tenemos dos opciones en un desplegable a elegir:
Repository: Nos permite buscar un esquema o query que tengamos creado en el repositorio
Built-in: Significa que generamos nosotros el esquema o query. En caso de Bulit-in también podemos utilizar el asistente «Guess» que nos propone el esquema o query.
Por otra parte junto a la query tenemos un botón con tres puntitos que nos abre el SQL Builder que nos permite generar la query de manera asistida y nos la permite ejecutar (botón señor corriendo) y en su caso depurar el script.
Configuración tLogRow
Este componente tiene muy poquita cosa a configurar, pero la visualización más cómoda es indicar en Mode «Table»
Vista Run del Job
Desde esta vista disponemos de botones desde los cuales podemos ejecutar el job, pararlo «kill» o limpiar la pantalla del job. También nos muestra el log de ejecución y entre el mismo como resultado del tLogRow, también muestra los datos de la consulta. En la derecha una tabla muestra las variables de contexto y contenido de las mismas.
Que más podemos hacer en un subjob:
Comprimir el Subjob: Es posible comprimir un subjob de manera que solo muestra el componente principal con un clic en «-» en el vertice superior izquierda del subjob.
Desactivar Subjob: Seleccionando el componente principal y luego botón derecho podemos desactivar un subjob para que no se ejecute y de igual manera lo podemos activar.
Tipos de flujo (Main/Iterate) y Disparadores (Trigger)
Hasta el momento hemos visto un tipo de fujo que es el «Main» que hace circular todo el caudal de datos, pero además disponemos de otro flujo de datos o manera de hacer circular los datos, que es el tipo «iterate»
Flujo de datos Iterate
Un flujo de datos tipo Iterate permite enviar los registros de uno a uno y son captados por una variable que podemos utilizar en un componente de manera iterativa. Como por ejemplo para enviar correos electrónicos a partir de los registros de una tabla de datos.
Disparadores Triggers
Los disparadores son otro tipo de conectores que nos permiten activar diferentes caminos de subjobs en función del resultado OK/Error de un subjob anterior.
En el ejemplo siguiente un disparador envia un correo electrónico si falla el job y si funciona correctamente abre un mensaje en pantalla.
Imagen del repositorio del apartado de metadata de conexiones a bases de datos
Repository: Metadata
Como continuación del tutorial anterior y avanzando en las opciones de la vista repositorio. El nodo «Metadata» nos permite gestionar conexiones, configuraciones y esquemas para extraer datos de diferentes orígenes para poder ser utilizados en múltiples componentes de un mismo job o diferentes jobs dentro de nuestro proyecto ahorrando tiempo y esfuerzos mediante la reutilización de tareas.
Conexiones a bases de datos
Empezamos creando una conexión a una base de datos desde el nodo «Db Connections» de la vista repository, botón derecho y clic en «Create connection»
Se nos abre una pantalla de creación, que ya nos empieza a resultar familiar, pues es idéntica a la que hemos estado viendo en la creación de otros elementos del repositorio como «Documents» y «Business Model». Una vez completado el «name», «purpose», «description» y «version» que queramos dar a la conexión, pulsamos «Next» y se nos abre una nueva pantalla de configuración de la conexión que debemos configurar.
Lo primero es seleccionar el tipo de base de datos que queremos conectarnos (En nuestro ejemplo MySQL) y también la versión de nuestro servidor de base de datos.
En server indicamos el host o IP en donde está la base de datos y finalmente entramos en login el usuario de la base de datos.
En port si no se ha modificado en principio mantenemos el que propone por defecto (en MySQL es el 3306) y finalmente mediante un clic en test para comprobar que la conexión se establece correctamente.
Esquema de Talend
Perfecto ya tenemos conexión.. ¿Que más cosas podemos hacer?
Lo primero conseguir los diferentes esquemas que podemos necesitar para nuestro desarrollo.
Antes de seguir avanzando hace falta explicar que es un esquema «schema» de Talend y para que sirve:
¿ Qué es un esquema «Schema» en Talend?
Un esquema en Talend es el que determina la estructura de datos que tienen las tablas de datos o datasets, concretando la estructura de campos y tipo de datos»data type» de las tablas de orígenes de datos que vamos a utilizar en nuestros desarrollos de jobs. Es importante indicar que siempre necesitamos establecer de manera obligatoria un esquema de datos en todos los componentes de imput de datos.
Extraer esquema de una base de datos
Podemos extraer los esquemas de las tablas de una base de datos de manera asistida. La manera de hacerlo es clicando el botón derecho sobre nuestra conexión y elegimos la opción » Retrieve Schema».
Seleccionamos el tipo de objeto de la base de datos (tablas o vistas) y mediante filtro con comodín % nos puede ayudar a buscar e identificar las tablas que queremos extraer los esquemas.
Seleccionamos las tablas del catálogo que necesitemos trabajar y finalmente «Finish».
Con los esquemas ya extraídos, Talend funciona como un completo cliente de la base de datos, desde el cual podemos generar querys y guardarlas en el repositorio para ser usadas en diferentes componentes de imput de datos.
Generar Query
En la conexión botón derecho y seleccionamos «Edit Query» en donde podemos consutar los contenidos de las tablas y probar y guardar querys en el repositorio para ser reutilizadas en nuestros jobs en los componentes de imputs de tablas de bases de datos.
En el tutorial anterior #1.Introducción de Talend Open Studio se mostraba como entrar en la herramienta y las primeras funcionalidades de la vista del panel de repositorio En este nuevo tutorial vamos a dar un paso más explicando más elementos de esta vista.
Business Model: ¿Qué es y para que sirve?
El Business Model es un diagrama del flujo del proceso que vamos a desarrollar. Dicho de una manera simple, es un croquis del proceso que vamos a construir.
La primera pregunta que igual alguien que se inicia en el desarrollo con Talend o con cualquier otra herramienta de Integración de datos es si es obligatorio el diagramar el proceso. La respuesta no puede ser otra que confirmar que no es obligatorio diseñar el «Business Model» pero se trata de una buena práctica.
La primera razón que disponer de un «Business Model» nos ayuda a documentar el proyecto, si tenemos muchos jobs y muy complejos tener documentado el proyecto con el «Business Model» nos ayudará a entender mucho mejor y mucho más rápido cuando queramos modificar cualquier desarrollo.
Una segunda razón es que el hecho de diagramar el proceso nos obliga a pensar el diseño antes de desarrollar, cosa que normalmente es muy rentable en horas.
Para los convencidos de que vale la pena diagramar o los que que estan acostumbrados a hacerlos, se les puede presentar la duda de si vale la pena diagramar el «Business Model» en Talend o hacerlo en otra herramienta que es mucho mejor para hacer estos mismos diagramas o de uso mas habitual. Dos posibles motivos para diagramar con el Mismo Talend son:
Quedan unidos al desarrollo en la misma herramienta cosa que además de ser cómodo los asocia para siempre de manera similar a cuando comentamos el código de un script.
Podemos asignar elementos técnicos de Talend por ejemplo jobs y la documentación que tenemos relacionada al projecto de Talend.
De forma similar a como creamos todos los elementos del repositorio con botón derecho nos permite crear un «Business Model» o crear unas carpetas que nos permita organizar el conjunto de los diferentes «Business Model» que consideremos crear dentro de un proyecto.
Al seleccionar «Create Business Model» y después de introducir los datos de creación se no abrirá un lienzo en donde podemos diseñar el diagrama de flujo y los componentes que necesitamos para ellos.
Antes que nada pantalla de creación es idéntica a la de creación de cualquier otro elemento del repositorio como ya vimos en el tema anterior al crear la documentación. Debemos introducir un nombre para el Business Model (sin separaciones y otros caracteres no permitidos), y de manera ya optativa introducir propósito y descripción, así como la versión modificable como ya vimos en el tema anterior con las teclas M/m.
El lienzo que se muestra es idéntico al que veremos en la creación de jobs y disponemos a la derecha de una paleta de componentes con las opciones básicas necesarias para preparar el diagrama de flujo.
Creación del diagrama del «Business Model»
Compontentes de formas y líneas de relación
Con doble clic sobre cada componente de la paleta o de manera equivalente con el puntero sobre sobre el lienzo. Componentes de diseño en la paleta tenemos de dos tipos las formas y las líneas de relación, aunque también tenemos varias opciones de incorporar textos y notas.
Aunque también podemos añadir otras formas, los componentes de forma son:
Decision: És una separación del flujo en función de un suceso, por ejemplo si se produce un error en una conexión el proceso toma una via y si no se produce el proceso sigue un camino distinto.
Action: Acción a realizar por parte de un proceso, por ejemplo una transformación, una query, etc…
Terminal: Forma que marca el inicio y final del flujo.
Data: Representa un cualquier conjunto de datos que se incorpora como flujo al proceso.
Document: Este componente representa un documento que se se genera como Output o corresponde a un Imput.
Imput: Corresponde a entradas manuales de datos.
List: Se trata de un subconjunto de datos que ha sido resultado de un tipo de proceso.
Actor: Es una persona que en el proceso debe realizar una acción o recibir un mensaje
Gear. Representa una acción máquina automatizada, en este caso puede representar un «Job»
Ellipse: Es una forma cuyo uso y significación puede ser personalizada.
Database: Representa una base de datos que el proceso interactua.
Relationship: Puede ser sin dirección, es decir conecta dos componentes que no tienen una secuencia o direccionalidad (Por ejemplo conexión de un componente con una nota). Pero también pueden tener direccionalidad en un sentido o doble sentido.
Notas y textos
En el diagrama de flujo podemos añadir una serie de notas y textos que nos van a ayudar a documentar y identificar los elementos del «Business Model».
Notas: Son campos de texto acompañados de un fondo que permiten incorporar textos amplios. Hay de dos tipos:
Notas generales o independientes incorporados directamente al lienzo.
Notas asociadas a un componente al que se une mediante una relación.
Textos: Son campos de texto más cortos y no acompañados de fondo.
Pongamos un ejemplo que ayude a entender mejor como funciona el diagramar el de flujo de un proceso.
Imaginemos que queremos extraer unos datos de la base de datos de un sistema de gestión ERP que queremos combinar con otros datos que podemos extraer de un fichero local, para después de un proceso de transformación preparar un reporte en formato hoja de cálculo.
Una buena manera de empezar es mediante una nota explicar el proceso mediante escribiendo en una nota general de cabecera.
Podemos añadir una nota situándonos en el lienzo y con botón derecho se nos abre un menú click en: add–> Note
Aparece la nota en donde podemos escribir. La nota de manera automáticamente se va dimensionando el tamaño. Si está seleccionada cualquier forma puede ser modificada en anchura, altura y posición son modificables directamente. Desde la vista de edición podemos cambiar el tipo de letra tamaño, estilo y color de la letra, así como el color del fondo.
También podemos relacionar una nota con otras notas o cualquier objeto mediante una linea de flujo o relación.
Doble clic en la paleta o desde el propio lienzo en los componentes que vamos a utilizar. iniciamos el proceso con la forma terminal que siempre nos marcarán el inicio y final del proceso.
Lo siguiente sería incorporar una forma de acción que represente el arranque programado de la tarea que pone en marcha el proceso. Conectamos los dos componentes con un flujo direccional. Los flujos los podemos conectar con los ports que nos aparecen al seleccionar las formas. Otra forma de hacerlo quizás más práctica es seleccionar el componente origen y luego con CTRL mantener seleccionado ese componente junto con el componente de destino y luego en la paleta seleccionar el componente de flujo relacional. Añadimos más notas relacionadas al componente con botón derecho sobre el componente.
Añadimos un componente «gear» que representa un job de Talend y para una mejor trazabilidad podemos assignar el correspondiente job o documento que tengamos en el repositorio simplemente arrastrando el job desde el respositorio al componente de forma que necesitemos.
A las líneas de relación también podemos añadir textos que expliquen la relación o textos libres en cualquier zona del lienzo.
Añadimos los elementos hasta completar el diagrama de flujos de todo el proceso.
Ya disponemos de Business Model. Genial!. La opción «save as» del menú nos permite modificar la versión que podemos cambiar a 0.2 o 1.1 o el número de versión que consideremos.
El botón derecho en el lienzo nos permite una amplia gama de opciones:
Add: Además de añadir notas y textos nos permite añadir más formas.
File: Imprimir y guardar el diagrama como archivo de imagen.
Arrange all: Organiza automáticamente los componentes del diagrama.
View: Nos permite añadir grid y reglas que nos ayudan a alinear mejor los componentes.
Seleccionando las líneas también podemos cambiar el tipo y grosor de línea así como su forma oblicua o rectilínia.
Talend Open Studio ( TOS para los amigos) es una suite que aporta un conjunto muy completo de herramientas de integración de datos que se ofrece en una versión de código libre Comunity Edition CE totalmente funcional. Dispone de una gran cantidad de componentes (más o menos unos 900) que permite hacer grandes cosas.
Conseguir la herramienta es un momento y no hace falta registrarnos, se descarga libremente y fácilmente desde la web de Talend. https://es.talend.com/download/.
Simplemente en la página de descargas seleccionamos el grupo de productos gratuitos y seleccionamos la aplicación Open Studio for Data Integration.
Si necesitamos más versiones las podemos descargar desde sourceforge:
Arrancar la aplicación no tiene tampoco ninguna complicación, ya que después de descomprimir la carpeta zip, lo único que hay que hacer es buscar en la carpeta principal el ejecutable que corresponda a nuestro sistema operativo. (En caso por ejemplo de windows el archivo ejecutable seria «TOS_DI-win-x86_64.exe»
Pantalla de inicio
Después de unos segundos nos aparece la pantalla de inicio, que se muestra en la imagen. Podemos seleccionar uno de los proyecto que tengamos creados en el nuestro espacio de trabajo. Si es la primera vez que entramos creamos un nuevo proyecto con «Create a new project»
También desde esta pantalla inicial, disponemos de la opción «Import an existing project» que permite importar un proyecto a partir de un fichero local. Además disponemos de la opción «Import a demo project» en el que Talend nos ofrece la oportunidad de importar un proyecto demo que nos ofrece un conjunto de jobs de demostración que ayudan a entender diferentes funcionalidades y componentes.
Entramos en la aplicación.
Conseguido entrar no? Esta es la parte fácil.
Si todo ha ido bien vamos a ver una página de bienvenida en donde se nos muestra los jobs más recientes y enlaces a recursos formativos y foros, así como informaciones de la versión de pago. No está mal para quien le apetezca, navegar un poco por el contenido para ver lo que se cuece..
Una vez cerramos la bienvenida, entramos por fin en la interfase gráfica de la aplicación. Wow que emoción :).
Si habéis trabajado con otras herramientas de integración de datos os parecerá un diseño como familiar, a mi me recuerda especialmente a Knime que también está basada en eclipse, y en algunas cosas también pero ya más diferente en la forma de trabajar al que ha sido un gran referente de los últimos años de integración de datos de código abierto Pentaho PDI.
Si echamos un vistazo general, vemos que como en casi cualquier programa, disponemos de una la barra de menú. También disponemos de la habitual línea de botones y finalmente un área de trabajo dividida en 5 bloques de vistas, que aunque os avanzo que podemos configurar y añadir más vistas o eliminar las que nos molesten. Mi consejo es que si estamos empezando a trabajar con la aplicación no variar esta configuración inicial, si desaparecen las vistas en las dos partes laterales superiores encontrareis el botón restaurar (Dos cuadraditos).
Bloques de Vistas de Talend Open Studio
Repository: Esta vista como su nombre indica, contiene un repositorio de diferentes elementos cuyo detalle iremos tratando. en este tutorial. Lo localizaremos inicialmente situado en la parte superior izquierda y siempre lo reconoceremos por estar identificado con el icono de una casita. En este panel vamos a poder gestionar todos los trabajos «jobs», documentación y configuraciones que forman parte de nuestro proyecto de integración de datos. La ventaja que nos ofrece Talend con este panel de repositorio, es que diferentes elementos como las las conexiones a las bases de datos, esquemas, templates, etc.. son de tipo compartido para todo el proyecto, cosa que nos va a generar un significativo ahorro de tiempo. Este panel de repositorio también ofrece una serie de botones que permiten por ejemplo maximizar, colapsar el árbol de nodos y otras opciones.
Panel de desarrollo. Este es el panel de la parte central y básicamente es el que contendrá el desarrollo de cada uno de los procesos. Podemos tener varios elementos abiertos de manera simultanea en distintas pestañas.
«Palette» o paleta de componentes. Este panel situado inicialmente en la parte derecha nos muestra los diferentes componentes disponibles para construir nuestro proceso de integración de datos.
Outline. Principalmente nos aporta una visión general del panel de desarrollo.
Editor. Es la vista contenida en el panel central inferior. Dispone de diferentes pestañas que nos serviran para configurar los diferentes elementos del proceso y también visualizar los logs.
Barra de menú de Talend Open Estudio.
Muchas de las opciones que encontramos en los menús, podemos también acceder a las mismas a partir de botones o combinació de teclas. Damos un pequeño repaso para que nos vayan sonando algunas cosas.
Un clic al menú File o ALT+F permite desplegar las diferentes opciones del este apartado. Como vemos, muchas opciones se pueden ejecutar como combinación de teclas Ctrl. Además de las opciones habituales que són muy comunes y que no hace falta comentar «Close/Save/Print/Restart/Exit». Nos aparece la opción de Switch Project o Workspace, que nos permite cambiar de proyecto e incluso de Workspace si disponemos de múltiples conexiones (opción de subscripción). El nodo de «Edit Project propierties» nos ofrece una amplia posibilidad de configuración de cada proyecto, así como la posibilidad de importar/exportar proyectos y un conjunto muy amplio de configuraciones mediante los nodos Import /Export. La opción de Menú Edit es totalemente estándard con las opciones habituales de deshacer, copiar, pegar, borrar y seleccionar.
Desde el menú Window con el nodo «Perspective» podemos administrar dos perspectivas o vistas. La primera perspectiva es la de «data integration» con los elementos básicos de la interfase gráfica de dataflow. La otra perspectiva «debug» es más técnica y nos permite depuraciones y un control de diferenteselementos del desarrollo de tipo más avanzado.
El nodo «show view» nos permite incorporar nuevas vistas a los paneles de trabajo, por ejemplo la vista «errorlog» que nos muestra tanto avisos como errores de ejecución . El nodo «Preferences» ofrece la posibilidad de configurar el área de trabajo desde múltiples perspectivas que van desde la apariencia a la gestión de actualizaciones, directorios de trabajo, etc…
Desde menú «Help» además de las esperables opciones de contenidos de ayuda, disponemos de un nodo que nos aporta la posibilidad de instalación e nuevos paquetes desarrollados básicamente por colaborares de la comunidad que aportan nuevas funcionalidades y un gestor de nuevos componente y actualizaciones. La opción de «Suport Logs» del menú es ciertamente útil si queremos guardar en una carpeta los diferentes logs de la aplicación en una carpeta comprimida.
Repositorio. Documentación
Primero de todo para entender las lógicas de como funciona el repositorio vamos a empezar con lo más fácil y no por ello menos importante que es incorporar documentos al proyecto.
Empezar diciendo, que para ser justos, no me parece especialmente frecuente encontrar proyectos de integración de datos bien documentados en la propia herramienta. Si el desarrollo corresponde a un consultor externo, quizás se sienta tentado a no ser muy transparente para no facilitar la tarea a un posible competidor. Quizás también ocurra que ya se esté documentado en otra herramienta de gestión de proyectos o de gestión documental.
El caso es que en mi opinión, una cosa no quita la otra y la ventaja que tiene documentar directamente en Talend es que siempre vamos a disponer la documentación junto al proceso, de forma similar a cuando se comenta el código de un script que siempre es de gran ayuda.
En todos los elementos del del repositorio podemos crear niveles de carpetas para estructurar la información
Mediante el nodo «add documentation» podemos añadir diferentes ficheros de documentación o carpetas completas en formato comprimido.
Una vez subidos los archivos, podemos actualizar la documentación mediante la opción «update» y guardando diferentes versiones del documento.
Control de versiones
Talend como filosofia nos permite guardar diferentes versiones, ya sean de documentos o jobs u otros elementos. Mediante la tecla M podemos guardar una nueva versión modificando de 0.1 a 1.1 y con la tecla m de 0.1 a 0.2.
