Hola Gente,
por estos días han presentado las nuevas características de Pentaho Data Integration 5 (PDI o Kettle), son realmente muchas y por demás interesantes,
aquí tienen la presentación del webex pasado, lamentablemente tuve que ver la versión offline ya que estaba de vacaciones.
Dentro de las nuevas características se encuentra una muy esperada, al menos por mí, se trata de la posibilidad de federar datos utilizando PDI.
Que es la federación de datos?
Bien, sin entrar en consideraciones técnicas diremos que la federación de datos es la posibilidad de vincular datos de orígenes heterogéneos (en esto PDI es excepcional!!!) y poder accederlos desde un único punto.
Ahora bien, PDI permite acceder prácticamente a lo que queramos, ahora bien, como accedemos luego?, bien lo haremos mediante el driver JDBC para Kettle, si si si, dije bien, ya disponemos de un driver JDBC para Kettle llamado (Thin Kettle JDBC driver).
No ahondaré mucho en teoría,
aquí hay un link para profundizar, lo que si haré es desarrollar un ejemplo exponiendo el resultado de una transformación como servicio y luego consumiéndolo desde una clase java, ejemplo que aun no he visto en la web.
Comencemos diciendo que hace falta la versión 5 de PDI que aún está en desarrollo y la pueden descargar desde
aquí.
Todo el material que explico lo pueden descargar desde
aquí.
Creando la transformación.
Una vez que nos encontramos en la UI de PDI (spoon) creamos una transformación y la guardamos con el nombre
listaPersonasDS.ktr, en mi caso la he almacenado en:
/home/mariano/Documentos/material-osbi/pdi-Dataservices/listaPersonasDS.ktr, llamemos a esta localización
TRANSF_HOME.
La transformación se verá finalmente como se muestra en la siguiente figura:
Es muy sencillo lo que esta transformación realiza solo une una tabla con datos de personas con una tabla con datos de canciones para conocer que canción le gusta a cada persona. Si bien el ejemplo es muy sencillo remarco que estamos accediendo a datos de orígenes diversos y herterogeneos, en algunos casos muy complejos de configurar y mantener, pero como ya he dicho antes "a esto se dedica don Kettle".
El paso (1) genera una tabla inline mediante el paso "Data Grid" con datos sobre personas, los datos son:
La metadata es:
El Paso (2) obtiene la lista de las canciones de un archivo txt mediante el paso "Input Text File", este archivo se encuentra en la web en la dirección:
https://raw.github.com/magm3333/material-osbi/master/pdi-Dataservices/listaCanciones.txt. Las canciones serán vinculadas a las personas mediante su clave (idCancion).
Los pasos (3) y (4) solo ordenan los datos por idCancion ya que el paso (5) así lo requiere.
Por último, el paso "salida" selecciona las columnas que serán el resultado final, se puede notar que este paso tiene un pequeño icono arriba a la derecha:
Este icono significa que este paso se está utilizando como paso de servicio, en otras palabras, desde este paso se expondrán los datos como servicio. Para realizar esta configuración presionamos
Ctrl+T para acceder a las propiedades de la transformación, luego en la pestaña "Data Service" indicamos los datos del servicio como lo podemos ver en la siguiente figura:
Es necesario dar un nombre al servicio, en este caso "listaPersonas" y seleccionar el paso del cual se obtendrás los datos de salida que serán expuestos. También tenemos la posibilidad de hacer caching de datos, solo recomendado para servicios cuyos datos no cambian.
Bien, eso es todo en cuanto a la transformación.
Configurando Carte:
Es mediante el servidor web
Carte que se prestará el servicio.
Carte permite realizar muchas tareas y
expone los comandos mediante servicios web RESTfull.
Podemos realizar configuraciones personalizadas a Carte de forma muy sencilla, vamos a configurar nuestro servicio de datos federado de esta forma. Solo debemos crear un archivo XML, en mi caso:
/home/mariano/Documentos/material-osbi/pdi-Dataservices/configuracionCarte.xml, llamemos a esta ruta
CARTECONFIG_HOME.
El contenido del archivo es:
<slave_config>
<slaveserver>
<name>slave1</name>
<hostname>localhost</hostname>
<port>8088</port>
</slaveserver>
<services>
<service>
<name>listaPersonas</name>
<filename>[TRANSF_HOME]</filename>
<service_step>salida</service_step>
</service>
</services>
</slave_config>
Como podemos ver es más que sencilla la configuración, solo debemos recordar bien el puerto y colocar correctamente el valor de
[TRANSF_HOME], en mi caso:
<filename>/home/mariano/Documentos/material-osbi/pdi-Dataservices/listaPersonasDS.ktr</filename>
Ejecutando Carte con la configuración personalizada:
Una ves que guardamos el archivo de configuración, abrimos un interprete de comandos de nuestro sistema operativo, nos posicionamos en la carpeta HOME de PDI y ejecutamos:
Linux o Mac OS:
sh carte.sh [CARTECONFIG_HOME]
Window$:
carte.bat [CARTECONFIG_HOME]
Podemos verificar el estado del servicio colocando en nuestro browser:
http://localhost:8088/kettle/status/, deberíamos ver algo así:
La clase java:
La clase java es muy sencilla y la muestro a continuación.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
public class TestPDIDS {
public static void main(String[] args) throws Exception {
Class.forName("org.pentaho.di.core.jdbc.ThinDriver");
Connection cn = DriverManager.getConnection(
"jdbc:pdi://localhost:8088/kettle",
"cluster", "cluster");
String sql = "SELECT nombre,so,cancion "+
"FROM listaPersonas "+
"WHERE edad<50 ORDER BY edad";
ResultSet rs = cn.createStatement().executeQuery(sql);
System.out.println("Nombre\t\tSO\tCanción");
System.out.println("------\t\t--\t-------");
while (rs.next()) {
String nombre = rs.getString(1);
if (nombre.length() > 7)
nombre += "\t";
else
nombre += "\t\t";
System.out.println(nombre + rs.getString(2) +
"\t" + rs.getString(3));
}
}
}
Como se puede apreciar es un programa que utiliza JDBC de forma estándar y sin sorpresas. Lo único a tener en cuenta es que la implementación de Driver es:
org.pentaho.di.core.jdbc.ThinDriver y la URL tiene la forma:
jdbc:pdi://localhost:8088/kettle luego el usuario y contraseña son:
clutser/cluster.
Respecto al soporte SQL, puede verse la información en la wiki de pentaho:
http://wiki.pentaho.com/display/EAI/The+Thin+Kettle+JDBC+driver
La salida luego de la ejecución de esta clase es:
Nombre SO Canción
------ -- -------
Sebastian Linux fusilados por la cruz roja
Catalina Linux toxi-taxi
Rodrigo Linux mi perro dinamita
Damian Window$ toxi-taxi
Dario Linux blues de la artilleria
Federico Linux musica para pastillas
Juan Linux un poco de amor frances
Emanuel Window$ fusilados por la cruz roja
Andrea Linux un poco de amor frances
Mariano Linux mi perro dinamita
Las librerías que necesité para que esta clase se ejecute correctamente son:
[PDI_HOME]/lib/kettle-core-TRUNK-SNAPSHOT.jar
[PDI_HOME]/lib/commons-vfs-20091118-pentaho.jar
[PDI_HOME]/lib/log4j-1.2.16.jar
[PDI_HOME]/lib/commons-logging-1.1.1.jar
[PDI_HOME]/lib/kettle-db-TRUNK-SNAPSHOT.jar
[PDI_HOME]/lib/kettle-engine-TRUNK-SNAPSHOT.jar
[PDI_HOME]/lib/commons-httpclient-3.1.jar
[PDI_HOME]/lib/commons-lang-2.6.jar
[PDI_HOME]/lib/commons-codec-1.5.jar
Si chequeamos el status nuevamente, aparecen las ejecuciones de nuestras consultas:
Luego podemos hacer click en cualquier consulta y nos mostrará detalles de la ejecución de la transformación:
Sin duda que pueden hacer uso de este driver desde otras tecnologías como: Pentaho Report Designer, BIRT, Jaspper Reports. Pentaho Schema Workbench, etc, pero queda fuera del alcance de este post.
Conclusión:
Que decir de esto que no se vea a simple vista, solo que es una característica nueva muy potente que otorga más flexibilidad al ya increíble PDI. Seguramente con el transcurrir del tiempo irá mejorando y creciendo, sobre todo dando más soporte a SQL.
Espero que les sea de utilidad
Saludos
Mariano
