Atelier : N°1

ETL avec Talend Open Studio

Pr. MOUNTASSER IMADEDDINE
Objectifs..................................................................................................................................................... 2
I. Installation de Talend Open Studio .................................................................................................. 3
II. Manipuler des Projets ....................................................................................................................... 3
II.1. Créer un Projet .......................................................................................................................... 3
II.2. Importer un Projet Demo.......................................................................................................... 4
II.3. Importer un Projet Local ........................................................................................................... 4
III. Conception des Jobs ...................................................................................................................... 4
III.1. Simple Job « Hello World » ....................................................................................................... 5
III.2. Premier Job ................................................................................................................................ 6
III.3. Manipuler des Fichiers .............................................................................................................. 8
III.4. Manipuler des BDs .................................................................................................................. 10
IV. Transformations .......................................................................................................................... 12
IV.1. Conversion des Types de Données ......................................................................................... 13
IV.2. Connecter Deux ou Plusieurs Composants............................................................................. 13
Annexe ..................................................................................................................................................... 15
ETL avec Talend Open Studio

Objectifs

Les systèmes d'information des entreprises deviennent de plus en plus complexes. Ainsi, l’enjeu
majeur consiste à réussir le processus d’intégration de données lorsque ses données sont
éparpillées dans différents types de systèmes d'information. Il est important de noter que les
fonctions qui se cachent derrière le principe d'intégration de données sont variées : l'intégration
décisionnelle (alimentation d'entrepôts de données) et l'intégration opérationnelle (capture et
migration de données, synchronisation de bases de données, échanges inter-applicatifs, etc.).
La solution d'intégration de données de Talend permet aux entreprises de gérer des systèmes
de plus en plus complexes en proposant des outils pour répondre aux besoins d'analyse et
d'intégration opérationnelle (qu'il s'agisse d'intégration décisionnelle ou opérationnelle) et en
offrant des fonctionnalités d'industrialisation ainsi que des capacités de monitoring décuplées.
Bien qu'ils soient généralement invisibles pour les utilisateurs de la plate-forme BI, les processus
d'extraction, de transformation et de chargement (ETL) reprennent les données de tous les
systèmes opérationnels et les pré-traitent pour les outils d'analyse et de reporting. En effet, les
processus ETL extraient les données des sources internes et externes d'une organisation,
transforment ces données et les chargent dans un entrepôt de données. Les processus ETL étant
complexes et coûteux, il est important de réduire leurs coûts de développement et de
maintenance. A cette fin, Talend fournit des outils de développement et de gestion unifiés pour
intégrer et traiter toutes vos données dans un environnement graphique simple à utiliser.

Studio Talend offre une très grande connectivité aux :

• Progiciels (ERP, CRM, etc.), bases de données, serveurs centraux, fichiers, Web Services,
etc. pour couvrir la disparité grandissante des sources.
• Entrepôts de données, magasins de données, applications OLAP (Online Analytical
Processing) pour l’analyse, le reporting, le dashboarding, etc.
• Composants ETL avancés stockés localement, incluant des manipulations de chaînes,
Dimensions à évolution lente, traitement automatique des références, etc.
Le présent atelier essaye d’illustrer et d’explique comment utiliser les fonctions de Talend
Studio dans un contexte opérationnel normal.

Pr. I.MOUNTASSER 2
 ETL avec Talend Open Studio

I. Installation de Talend Open Studio

Tous les produits de la version communautaire Talend sont issus d'un environnement d'outils basé sur
Eclipse et conditionnés sous forme d'archive. Pour installer TOSBD, il vous suffit d'extraire l'archive, de
préférence, sous un chemin ne contenant aucun espace. En effet, ce produit est générique et
conditionné dans une seule archive pour plusieurs environnements ; ainsi, exécuter TOSBD consiste
simplement à choisir le bon fichier exécutable dans le répertoire d'installation.

Tous les noms de fichiers exécutables ont la même syntaxe : TOS_BD-[Système d'exploitation]-
[Architecture]-[Extension]. Donc, pour exécuter TOS_BD sur une machine Windows 64 bits, TOS_BD-
win-x86_64.exe doit être exécuté. Choisissez simplement celui qui correspond à votre configuration. La
première fois que vous exécuterez le studio, une fenêtre apparaîtra vous demandant d'accepter les
conditions d'utilisation et le contrat de licence ; une fois accepté, l'assistant de configuration du projet
apparaîtra. Il présente le projet existant, dans notre cas, seul le projet démo par défaut existe. L'assistant
propose également d'importer ou de créer un projet.

II. Manipuler des Projets

Lorsque vous lancez votre Talend Studio pour lancer un Job d'intégration de données, ou n'importe
quelle autre tâche, vous devez d'abord créer ou importer un projet. Dans Talend Studio, le "projet"
correspond au nœud racine stockant les différents types de Jobs d'intégration de données,
métadonnées, routines, etc. A partir de la fenêtre de login du Talend Studio, vous pouvez :
► Créer un projet local :
Lorsque vous démarrez le Studio avec une licence chargée localement pour la première fois, aucun
projet par défaut n'apparaît dans la liste. Vous devez créer un projet qui contiendra tous les Jobs
d'intégration de données et les Business Models que vous créez dans le Studio. Vous pouvez créer autant
de projets que vous le souhaitez pour stocker les données de vos différentes instances du Studio.
Lorsque vous créez un nouveau projet, une arborescence est automatiquement créée dans le répertoire
workspace du serveur de votre référentiel. Il correspond à la vue Repository de la fenêtre principale du
Talend Studio.
► Importer le projet Demo :
Cela permet de découvrir les fonctionnalités du Talend Studio grâce à des exemples de Jobs prêts à
l'emploi. Lorsque vous importez le projet Demo, il est automatiquement installé dans le workspace de
votre instance courante du Studio.
► Importer/Ouvrir des projets :
Cela vous permettrez d’importer des projets que vous avez déjà créés dans une version antérieure du
Studio Talend à partir du workspace courant du Talend Studio. Du même, vous pouvez ouvrir un projet
que vous avez créé ou importé dans le Studio ou ouvrir un projet stocké dans un référentiel distant.
D’autres parts, une fois que vous avez lancé Talend Studio, vous pouvez exporter les ressources d'un ou
de plusieurs projets créés à partir de l'instance courante du Studio.
II.1. Créer un Projet
Pour créer un projet local lors du premier démarrage du Studio, procédez comme suit :
1. Lancez Talend Studio et connectez-vous au référentiel local.
2. Dans la fenêtre de connexion, sélectionnez l'option « Create a new project » et saisissez un nom
de projet dans le champ.
3. Cliquez sur Finish pour créer le projet et l'ouvrir dans le Studio.
Il est important de noter que dans le Studio, si vous souhaitez passer d'un projet à un autre, cliquez sur
File > Switch Project or Workspace dans la barre de menu.

Pr. I.MOUNTASSER 3
 ETL avec Talend Open Studio

II.2. Importer un Projet Demo

Vous pouvez importer, dans votre workspace, le(s) projet(s) Démo contenant de nombreux exemples
de Jobs prêts à utiliser dans votre Talend Studio pour vous aider à comprendre les fonctionnalités des
différents composants Talend. Pour importer un projet Démo, procédez comme suit :
1. Lorsque vous démarrez votre Studio Talend, sélectionnez l'option Import a demo project dans
la fenêtre de connexion du Studio et cliquez sur Select, ou cliquez sur le lien Demos dans la
fenêtre de bienvenue, pour ouvrir la boîte de dialogue [Import demo project].
2. Dans la boîte de dialogue [Import Demo Project], sélectionnez le projet Démo à importer et
regardez sa description dans le panneau de droite.
3. Cliquez sur Finish pour fermer la boîte de dialogue.
4. Dans la nouvelle boîte de dialogue qui s'ouvre, saisissez un nom de projet et une description, si
nécessaire.

Tous les exemples du projet Démo sont importés dans le projet créé et le nom du nouveau projet
s'affiche dans la liste Project de l'écran de connexion. Egalement, les exemples de Jobs du projet Démo
ouvert sont automatiquement importés dans votre répertoire Workspace et sont disponibles dans la
vue Repository (Référentiel), sous le dossier Job Designs.

II.3. Importer un Projet Local

Dans le Studio Talend, vous pouvez importer un ou plusieurs projets que vous avez déjà créés dans une
version antérieure du Studio. Pour importer un projet, procédez comme suit :
1. Dans la fenêtre de connexion du Studio, sélectionnez « Import an existing project » puis cliquez
sur Select pour ouvrir l'assistant [Import].
2. Cliquez sur le bouton « Import project as » et saisissez un nom pour votre nouveau projet dans
le champ Project Name.
3. Cliquez sur Select root directory ou Select archive file selon la source de laquelle vous souhaitez
importer.
4. Cliquez sur Browse... pour sélectionner le répertoire Workspace/le fichier d'archive du dossier
du projet spécifique. Par défaut, le Workspace sélectionné est celui qui correspond à la version
de votre Studio. Parcourez votre système jusqu'au répertoire Workspace du Studio contenant
les projets à importer.
5. Cliquez sur Finish pour valider l'opération et retourner à la fenêtre de connexion.

III. Conception des Jobs

Les fonctionnalités du Talend Studio permettent de traiter toutes les sources et les cibles utilisées dans
un processus d'intégration de données, ainsi que toutes les opérations associées. Les Jobs d'intégration
de données que vous modélisez dans Talend Studio, vous permettent de mettre en place des processus
de gestion des flux de données directement exécutables. Pour cela, cette section s'adresse aux
ingénieurs et analystes de données qui souhaitent mettre en place la couche technique d'un processus
d’intégration, basé (ou non) sur un Business Model du Talend Studio.

Premièrement, un Job constitue la couche d'exécution ou l'implémentation technique d'un Business

Model. Il est la représentation graphique et fonctionnelle d'un ou plusieurs composants connectés,

Pr. I.MOUNTASSER 4
ETL avec Talend Open Studio

permettant de définir et d'exécuter des processus de gestion de flux de données. Il traduit les besoins
métier en code, en routines ou en programmes, puis se charge d'exécuter ces derniers. En d'autres
termes, le Job permet de mettre en place votre flux de données.

Les Jobs que vous créez peuvent gérer les différentes sources et cibles dont vous avez besoin lors de vos
processus d'intégration de données, ou lors de tout autre processus lié. Avec le Studio Talend, vous
pouvez :

► Modéliser des actions d'intégration de données grâce à la bibliothèque de composants

techniques.

► Changer les paramètres par défaut des composants et même créer de nouveaux composants ou
familles de composants qui correspondent au mieux à vos besoins.

► Paramétrer les connexions et les relations entre composants afin de définir la nature des actions
et leur déroulement.

► Accéder au code généré pour le programme ou les composants afin de le modifier ou de le

documenter.

► Créer et ajouter des éléments au Repository (Référentiel) à des fins de réutilisation et de partage
(avec d'autres projets, d'autres processus ou, à moyen terme, avec d'autres utilisateurs).

III.1. Simple Job « Hello World »

Cette section présente un exemple simple qui montre comment créer un Job, ajouter des composants,
les configurer et finalement exécuter ce Job. Nous allons donc créer un exemple "hello world" dans
Talend. Le Studio Talend vous permet de créer un Job en déposant différents composants techniques
de la Palette dans l'espace de modélisation graphique, puis en connectant ces composants les uns aux
autres. En fait, nous allons utiliser le composant tMsgBox dans ce petit exemple, qui nous montrera une
boîte de message. Pour faire cela pratiquement (Figure 1), ouvrez Talend Open Studio, créez un job et
vous lui donnez un nom. Cela va ouvrir un espace de travail vide.

Une fois le Job créé, il faut ajouter des composants dans l'espace de modélisation graphique. Pour ce
faire, différents moyens existent :

► Trouver votre composant dans la Palette en saisissant des mots-clés dans le champ de recherche
et le déposer dans l'espace de modélisation graphique.
► Ajouter un composant en saisissant directement des mots-clés dans l'espace de modélisation
graphique.
► Ajouter un composant de sortie en le glissant depuis un composant d'entrée déjà dans l'espace
de modélisation graphique.
► Glisser-déposer un élément de métadonnées centralisé depuis le Metadata dans l'espace de
modélisation graphique et sélectionner le composant qui vous intéresse dans la boîte de
dialogue Components.

Dans cet exemple, insérez un composant tMsgBox soit en allant sur le côté droit, i.e. la "Palette" et
recherchez, soit via une option beaucoup plus simple, que nous allons utiliser plus fréquemment (clic
gauche dans la zone centrale et commencez à écrire des parties du nom du composant). Un double clic
sur son icône, m'amène aux paramètres de ce composant. Par exemple, vous pouvez changer un peu le
texte du message qui sera affiché. Maintenant vous êtes capable d'exécuter le job. Allez dans l'onglet
"Exécuter", et cliquez sur exécuter, ensuite la fenêtre avec le message saisi est affichée.

Pr. I.MOUNTASSER 5
ETL avec Talend Open Studio

Figure 1. Exemple Hello World

III.2. Premier Job

Dans cette section, nous allons construire un job qui utilise trois composants, à savoir, tRowGenerator
pour générer des données, tMap pour les transformer et tLogRow pour sortir ces données vers la
console.

Similairement au job précédent, vous créez un job, nommé « First_Job » et vous aurez un espace de
travail vide, dans lequel vous allez insérer les composants demandés. Maintenant que les composants
sont ajoutés dans l'espace de modélisation graphique, ils doivent être connectés entre eux. Lorsque des
composants sont connectés, ils forment un sous-job. Les Jobs sont composés d'un ou plusieurs sous-
jobs effectuant différentes opérations. Maintenant, vous pouvez connecter ces composants,
simplement en spécifiant des liaisons entre eux (sélectionnez l'icône du composant puis tracez la
liaison). Afin de relier les composants, la première alternative consiste à cliquer-droit sur le composant
source, et dans le menu contextuel qui s'ouvre, sélectionner le type de connexion que vous souhaitez
utiliser afin de relier les composants (ex. Main). Il faut noter que selon la nature et le rôle des
composants que vous souhaitez connecter, différents types de liens sont disponibles. Seules les
connexions autorisées sont répertoriées dans le menu contextuel. La deuxième alternative est un simple
glissé-déposer. Cliquez sur le composant d'entrée, et faites glisser votre curseur sur le composant de
destination. Un lien est automatiquement créé entre ces deux composants.

Maintenant l’étape suivante consiste à configurer les composants. Commençant avec le composant
tRowGenerator (Double-cliquez sur l’icône du composant, Figure 2). Dans ce cas, cela nous amène à un
éditeur spécial pour ce composant, et la première chose que nous devons faire est de spécifier un
"schéma" (appuyant deux fois sur le [+] vert) en insérant deux colonnes. La première doit être un "id",
un identifiant, la deuxième un "nom". Pour l'identifiant, il faut s’assurer qu'il s'agisse de nombres entiers,
en sélectionnant donc le type de données "Integer" et pour l’autre élément, vous spécifiez le type
"String".

Maintenant pour les "ids", nous allons utiliser une fonction qui est déjà livrée avec Talend
(Numeric.sequence). Ensuite, pour créer un nom, Talend est également livré avec une classe, qui
s'appelle "TalendDataGenerator" et qui a quelques méthodes (nous utilisons une méthode s'appelle
"getFirstName"). Finalement, la dernière chose que nous allons faire, est de spécifier le nombre de lignes
qu’on veut générer. Vous pouvez appuyer sur le bouton de prévisualisation dans le coin supérieur droit

Pr. I.MOUNTASSER 6
ETL avec Talend Open Studio

pour voir un petit aperçu. Maintenant, ces données avec ce schéma sont passées deux fois au composant
tMap pour transformer les données.

Figure 2. Configuration du Composant tRowGenerator

Les noms sont écrits avec une première lettre majuscule et le reste en minuscules. Vous allez essayer de
les convertir en majuscules. Tout d’abord, double clic sur l’icône tMap (Figure 3) et vous allez trouver
notre entrée, avec ces deux colonnes, et la sortie (appelée TransformedData) qui n’a pas encore de
schéma. En effet, on veut que la sortie contienne les deux colonnes d'entrée mais avec le deuxième
champ en majuscule. Pour ce faire, sélectionnez ces deux champs, puis faite un glisser-déposer sur la
partie droite. Maintenant, sur l'expression de champ "input.name", vous pouvez appliquer une fonction
toUpperCase ou "StringHandling.UPCASE" qui convertit les lettres minuscules d'une expression en
majuscule. Cliquez sur "Tester !" et vous verrez la sortie respective pour cette colonne après avoir
appliqué cette petite transformation. Cliquez sur «OK» pour propager le changement du schéma à notre
composant tLogRow.

Pr. I.MOUNTASSER 7
ETL avec Talend Open Studio

Figure 3. Configuration du Composant tMap

La dernière manipulation à réaliser consiste à passer le composant tLogRow au mode en "table". Bien
évidemment, cela permet de mieux lire les données sur la console (i.e. le résultat final de la
manipulation. Maintenant, nous sommes prêts à exécuter notre job).
Maintenant que les composants sont configurés, le Job peut être exécuté. Pour ce faire, procédez
comme suit : Appuyez sur Ctrl+S afin de sauvegarder votre Job, puis ouvrez l'onglet Run et cliquez sur
Run afin d'exécuter le Job. Les champs extraits sont affichés donc dans la console.

Figure 4. Exécution du Job

III.3. Manipuler des Fichiers

Dans cette section, vous allez apprendre à traiter des fichiers avec Talend. Nous allons lire et écrire
différents formats, tels qu'un simple fichier texte, Excel, et d'autres formats. Premièrement, nous allons
lire un fichier, nommé "sales.csv", avec le composant tFileInputDelimited afin de montrer simplement

Pr. I.MOUNTASSER 8
ETL avec Talend Open Studio

son contenu sur la console, à l'aide d'un composant tLogRow. Vous pouvez constater qu'il y a pas mal
d'informations que nous devons définir pour le fichier, à savoir, son emplacement, son séparateur de
lignes, séparateur de champs, schéma et quelques autres propriétés. En effet, Talend nous propose une
solution très simple pour définir tout cela (Figure 5). Sur le volet « Référentiel \ Repository», nous avons
l’entrée "Métadonnées" avec une option "Fichier délimité". C'est là que nous allons d'abord créer les
informations pour le "sales.csv", en faisant un clic droit dessus et en sélectionnant "Créer un fichier
délimité". Maintenant, spécifiez un nom et sélectionnez le fichier en question.

Figure 5. Lire un Fichier CSV

A ce stade, vous pouvez déjà voir un court aperçu du fichier. On trouve les noms de colonne "Store",
"Date" et "Sales" qui correspondent respectivement aux noms des magasins, les dates auxquelles une
vente a été effectuée et un montant pour cette date. Alors maintenant, vous allez à "Suivant", et vous
pouvez voir que Talend définit quelque chose qui s'appelle "Column 0" (car il utilise la valeur par défaut),
un point-virgule comme séparateur de lignes, ce qui n'est pas convenable dans notre cas (car le fichier
contient des virgules comme séparateurs de champs). Si vous sélectionnez cela et que vous cliquez sur
"Actualiser l'aperçu", vous allez déjà constater qu'il sera divisé en trois colonnes. Cependant, les
colonnes génériques doivent être éliminées car les colonnes sont déjà contenues dans le fichier. Nous
pouvons donc les utiliser en sélectionnant cette option "Définir la ligne d'en-tête comme noms de
colonne" et actualiser à nouveau l'aperçu. Dans l'étape suivante, nous devons définir un schéma, par
exemple, "salesSchema" et nous pouvons voir le fichier dans le navigateur de fichiers. Ainsi, vous pouvez
configurer le schéma en modifiant par exemple le format de la deuxième colonne de type Date (utilisez
[Ctrl] + [Espace] pour en sélectionner un autre). Il faut noter qu’une fois le fichier est défini, vous pouvez
ensuite l’utiliser dans plusieurs scénarios sans devoir le redéfinir à nouveau.

Maintenant, vous pouvez l’utiliser (en le faisant glisser et en le déposant dans l’espace de travail tout en
le convertissant en un tFileInputDelimited), dans un job nommé "read sales.csv" qui affichera le résultat

Pr. I.MOUNTASSER 9
ETL avec Talend Open Studio

du fichier dans la console. Ainsi, cherchez un composant tLogrRow, et changez son mode à l’option table,
puis connectez ces deux composants ensemble.

Figure 6. Exécution du Job avec le Fichier CSV

III.4. Manipuler des BDs

Dans cette section, nous traiterons des bases de données. Alors tout d'abord, je vais vous montrer
comment vous connecter et comment stocker ces informations dans des métadonnées. Ensuite, nous
allons écrire des données dans votre base de données, le lire à partir d'un tableau, et nous allons
également parcourir certains objets de la base de données.

La question à poser maintenant est quelle est votre base de données. Avec Talend, vous pouvez utiliser
n'importe laquelle des principales bases de données. Mais dans notre exemple en particulier, nous allons
utiliser MySQL. Donc pour pouvoir suivre exactement ce qui est indiqué ci-dessous, alors vous utiliseriez
MySQL. Mais tout autre est à peu près similaire.

Premièrement, nous allons se connecter à une base de données dans Talend (Figure 7). Pour cela, nous
allons utiliser le composant tDBConnection comme composant central de notre tâche de connexion.
Allez dans la palette, et dans la catégorie "Database" > "Spécificités de la base de données", le
composant que nous allons utiliser est le tMySQLConnection. Vous verrez que vous pouvez faire quelque
chose de similaire pour de nombreux autres types de bases de données. Ensuite, créez une connexion
dans "Repository" sous "Metadata" > "DB connections". Appelez le par exemple "mysqlLocal" et
sélectionnez "MySQL" comme type de base de données. Entrez les informations de connexion et testez
votre connexion. Maintenant, vous pouvez l'utiliser par glisser-déposer, en le convertissant en
tDBConnection. De plus, si vous avez déjà le composant ici, vous pouvez le faire glisser et le déposer et
mettez-le sur le composant qui est déjà là. Il utilise donc les informations du référentiel, selon vos
préférences.

En ce qui suit, nous allons ajouter deux autres composants, un pour voir si tout va bien, qui est le
tMsgBox et l'autre pour s'assurer que cela est exécuté avant toute autre chose, qui est tPreJob. Nous
allons donc connecter ces composants ensemble à partir du tPreJob. Nous n'avons que le déclencheur
"On Component Ok". Nous connectons donc cela à mysqlLocal, à ce composant tDBConnection. Nous
allons afficher ce tMsgBox qui devrait juste dire quelque chose comme "DB running". Vous pouvez donc
exécuter ce Job.

Pr. I.MOUNTASSER 10
ETL avec Talend Open Studio

Figure 7. Etablir un connexion avec BD MySQL

Maintenant, nous allons écrire des données dans une base de données avec Talend (Figure 8). Pour cela,
nous allons réutiliser le "sales.csv" que nous avons manipulé précédemment et l'écrire directement sans
aucune transformation dans une base de données en utilisant le composant tDBOutput. Nous allons
également réutiliser le job de connexion déjà établi. Ainsi, cliquez droit dessus et sélectionnez
"Dupliquer" et renommez le "dbWrite". Ensuite, glissez et déposez le fichier csv à partir de metadata et
convertissez-le en tFileInputDelimited. En ce moment, nous établissons toujours une connexion à la base
de données. Donc, prenez cette connexion et glissez-déposez-la dans l’espace de travail comme
tDbOutput(MySQL). Ici, nous n'avons plus besoin des informations de connexion, car nous l’avons déjà
établi dans le premier sous-job. Elle sera utilisée via l’option "Utiliser une connexion existante". De plus,
il faut au moins donner un nom de table. Pour un bon fonctionnement, nous sélectionnons l'"Action sur
la table" -> "Supprimer la table si elle existe et créer". Nous pouvons donc exécuter ce travail plusieurs
fois sans problème. Maintenant, au cas où tout irait bien, il faut que la validation (commit) soit faite.
Pour cela, recherchez le composant commit (tMySQLCommit) et pour le cas où il y aurait une erreur,
sélectionnez le tMySQLRollback. Ensuite, connectez les déclencheurs respectifs, notamment, "On
Component Ok" pour un commit et "On Component Error" pour un rollback. Après exécution, essayez
de vérifier dans le SGBD que la table a été chargée.

Figure 8. Ecrire les données dans une BD

Pr. I.MOUNTASSER 11
 ETL avec Talend Open Studio

Concernant la lecture à partir d’une base de données (Figure 9), nous allons premièrement créer un
autre Job en dupliquant un des jobs déjà élaborés. Vous allez utiliser le composant tDBInput pour lire
une table que nous avons écrite auparavant, qui est notre table de "ventes". Ce que nous allons faire en
premier, c'est un clic droit. Si vous regardez votre connexion à la base de données, elle contient des
sous-entrées où différents schémas existent. Nous allons donc récupérer le schéma de cette table, que
nous allons lire en premier. Nous faisons donc un clic droit sur la connexion et sélectionnons "Récupérer
le schéma". Ensuite, faites glisser et déposer dans l’espace de travail et convertissez le en tDBInput, car
nous allons lire à partir de la base de données. Nous allons "Utiliser une connexion existante" et
sélectionner la connexion respective. Vous allez retrouver que le nom de la table est déjà là car nous
l'avons récupéré de la base de données et aussi une requête avec un "select *", bien que vous puissiez
ajouter juste cela, en mettant une clause where ou en sélectionnant moins de colonnes. Mais pour le
moment, cela nous convient et nous nous contenterons d'afficher ces informations sur la console via le
composant tLogRow en mode table. Après lecture, nous allons besoin de se déconnecter à nouveau.
Pour cela, Nous allons explicitement fermer la connexion et la connecter à un composant tPostJob. Nous
sélectionnons donc le composant tPostJob et nous allons rechercher le tMySQLClose.

Figure 9. Lire les données à partir d'une BD

IV. Transformations
Des données propres, opportunes et correctes constituent une ressource essentielle pour la plupart des
organisations, car elles permettent une prise de décision plus précise, une conformité et une efficacité
améliorée.

L'intégration des données est souvent le premier point de contact pour les données arrivant dans une
entreprise (provenant de tiers) et la plaque tournante des données détenues au sein d'une entreprise
et, à ce titre, joue un rôle clé pour garantir que les données sont aptes à être utilisées. Cette section se
concentre sur certaines fonctionnalités et méthodes de Talend qui permettent au développeur d’assurer
le processus d’intégration.

Pr. I.MOUNTASSER 12
ETL avec Talend Open Studio

IV.1. Conversion des Types de Données

Dans cette section, nous allons essayer de convertir des types de données. Dans le job
convertDataTypes (à créer), nous utiliserons premièrement le composant tConvertType pour convertir
certaines valeurs numériques en nombres entiers (Figure 10). Sélectionnez tout d’abord un composant
tFixedFlowInput qui sera utilisé comme entrée du processus de conversion.

Figure 10. Conversion de types de données.

Nous avons une colonne String, et nous allons la convertir en Integer. La colonne Integer continue
également d'être un entier, et puis FloatToInteger est une colonne Float, que nous convertissons
également en Integer. Dans le composant tConvertType, vous devrez "Modifier le schéma". Nous avons
un schéma d'entrée, et nous avons besoin également d'un schéma de sortie. Ainsi, vous pouvez
transmettre toutes les colonnes à la sortie. Mais comme nous l'avons déjà mentionné, nous voulons
convertir toutes ces colonnes en Integer. Changez premièrement le type et cochez ensuite « Auto Cast »
ou conversion automatique. Finalement, essayez d’afficher le résultat via un tLogRow. Il faut noter que
vous pouvez en ajouter un tLogRow de plus qui affichera une sortie pour les informations qui ne peuvent
pas être convertis (Lien rejects) avec d’autres colonnes signalant le code et message d’erreur (errorCode
et errorMessage). Veuillez synchroniser les colonnes (tLogRow) pour pouvoir exécuter ce processus et
voir le résultat respectif.

IV.2. Connecter Deux ou Plusieurs Composants

Dans cette section, nous allons essayer de joindre plusieurs niveaux dans Talend. A cet effet, cette partie
traite principalement le composant tMap qui est généralement le principal composant de traitement au
cœur de toute tâche de transformation Talend. Le composant tMap possède des capacités de
transformation étendues et est ainsi devenu l'outil de choix du développeur d'intégration de données.
Parmi les capacités du composant tMap figurent la capacité d’ajouter et supprimer des colonnes,
d’appliquer des règles de transformation à une ou plusieurs colonnes, de filtrer les données d'entrée et
de sortie, de joindre des données provenant de plusieurs sources en une ou plusieurs sorties et de diviser
les données source en plusieurs sorties.

Pr. I.MOUNTASSER 13
ETL avec Talend Open Studio

Nous allons joindre trois ensembles de données (Figure 11), avec plus de flexibilité en termes de
transformation. Nous manipulons donc une table des films, une table avec des acteurs, et une table des
ponts, qui contient de nombreuses combinaisons d'identifiants d'acteurs et d'identifiants de films. Ainsi,
glissez et déposez ces trois dans l’espace de travail, convertissez chacun en tDBInput. Ensuite ajoutez le
composant tMap. Le premier que nous connectons est automatiquement "Main", Les autres sont du
type "Lookup". Essayez maintenant d’accéder à votre tMap en double-cliquant sur son icône. Vous allez
retrouver vos entrées sur le côté gauche, les variables au milieu et les sorties à droite que nous allons
les créer dans un instant. Mais d'abord, nous nous occuperons de la jointure sur le côté gauche. Vous
avez un "film_id" dans l’entrée "film" et vous avez un "film_id" dans l’entrée lookup "film_actor". Donc,
une option pour les connecter est par glisser-déposer. En revanche, la table "film_actor" peut avoir de
nombreuses combinaisons de films avec des acteurs. C’est pour cela que vous devez configurer les
paramètres du tMap (petite icône avec le point rouge dessus). En d’autres termes, cela signifie qu’on
cherche non seulement une « correspondance unique », mais "toutes les correspondances" possibles,
et nous voulons que ce soit une "jointure interne". Pour la deuxième liaison lookup, vous accédez
également aux paramètres du tMap (on garde la correspondance unique). Maintenant, vous devez créer
une sortie et lui donner également un nom descriptif "film_actor_joined" tout en spécifiant les colonnes
à inclure dedans. Il faut noter que vous pouvez créer une deuxième sortie, qui devrait capturer les rejets
de jointure. Vous pouvez mettre quelques informations comme le "film_id", et pour que cela fonctionne,
sélectionnez "True" pour cette option "Rejeter la jointure interne de recherche de capture" (paramètres
du tMap).

Figure 11. Jointure Multiple via tMap

Lorsque vous effectuez une jointure explicite dans le tMap, vous pouvez définir un modèle de
correspondance. Il a différentes options :
• Correspondance unique : Sélection par défaut. Elle fonctionne avec la jointure interne et la
jointure externe gauche, où seule la dernière correspondance sera transmise à la sortie (les
autres correspondances seront ignorées).
• Première correspondance : Elle fonctionne avec la jointure interne et la jointure externe gauche
et implique plusieurs correspondances attendues. Seule la première correspondance est
transmise à la sortie (les autres correspondances seront ignorées).

Pr. I.MOUNTASSER 14
ETL avec Talend Open Studio

• Toutes les correspondances : Elle Fonctionne avec la jointure interne et la jointure externe
gauche et implique plusieurs correspondances attendues. Dans ce cas, toutes les
correspondances seront transmises à la sortie (aucune correspondance ignorée).
• Toutes les lignes : Elle ne fonctionne pas avec la jointure interne et la jointure externe gauche
et crée une jointure croisée entre l'entrée principale et les entrées Lookup.

Annexe
Talend vous propose une gamme de Studios open source et par abonnement que vous pouvez utiliser
pour créer vos projets et gérer des données de tout type ou volume. À l'aide de l'interface utilisateur
graphique et de centaines de composants et connecteurs prédéfinis, vous pouvez concevoir vos Jobs
avec une interface glissé-déposer et une génération de code natif. Les fonctionnalités clés du Studio
Talend sont accessibles sous différentes perspectives. La disponibilité des perspectives dépend de votre
licence dans le cas d'un projet local, ou du type de votre projet distant. Dans Talend, un Job ou un sous-
Job est composé d'un groupe de composants logiquement liés les uns aux autres via des connexions.
Donc, qu'est-ce qu'une conception de job ?
Une conception de job est une conception graphique, composée d'un ou plusieurs composants
connectés entre eux, qui vous permet de configurer et d'exécuter des processus de gestion de flux de
données. Elle traduit les besoins métier en code, routines et programmes, en d’autres termes il
implémente techniquement votre flux de données. Les Jobs que vous concevez peuvent répondre à
toutes les différentes sources et cibles dont vous avez besoin pour les processus d'intégration de
données et tout autre processus associé. Lorsque vous concevez un Job dans le Studio Talend, vous
pouvez :
• Mettre en place des actions d'intégration de données à l'aide d'une bibliothèque de composants
techniques.
• Modifiez le paramètre par défaut des composants ou créez de nouveaux composants ou une
nouvelle famille de composants pour répondre exactement à vos besoins.
• Etablir des connexions et des relations entre les composants afin de définir la séquence et la
nature des actions.
• Accéder au code à tout moment pour éditer ou documenter les composants du Job conçu.
• Créer et ajouter des éléments au référentiel à des fins de réutilisation et de partage (dans
d'autres projets ou Jobs ou avec d'autres utilisateurs).
Premièrement, vous devez utiliser les connexions pour définir la façon dont les composants utilisés sont
coordonnés. Par conséquent, la section suivante décrira les types de connexions et leurs paramètres
associés.

Types de Connexion
Il existe différents types de connexions qui définissent soit les données à traiter, la sortie des données
ou la séquence logique du Job. Cliquez avec le bouton droit sur un composant dans l'espace de
modélisation graphique pour afficher un menu contextuel répertoriant toutes les connexions
disponibles pour le composant sélectionné.
Row connection : Cette connexion gère les données réelles. Elles peuvent être principales (Main), de
recherche (Lookup), de rejet, de sortie, uniques/doublons ou combinées selon la nature du flux traité.
• Main : transmet les flux de données d'un composant à l'autre, en itérant sur chaque ligne et en
lisant les données d'entrée en fonction du paramètre des propriétés du composant (schéma).
Les données transférées via les lignes principales sont caractérisées par une définition de
schéma qui décrit la structure des données dans le fichier d'entrée.
• Lookup : connecte un composant de sous-flux à un composant de flux principal (qui doit être
autorisé à recevoir plusieurs flux entrants). Cette connexion n'est utilisée que dans le cas de flux

Pr. I.MOUNTASSER 15
ETL avec Talend Open Studio

d'entrée multiples. Elle peut être transformée en ligne principale à tout moment (et
inversement). Pour ce faire, cliquez avec le bouton droit sur la ligne à modifier et, dans le menu
contextuel, cliquez sur Définir cette connexion comme principale.
• Rejects : connecte un composant de traitement à un composant de sortie. Cette connexion de
ligne rassemble les données qui ne correspondent pas au filtre ou qui ne sont pas valides pour
la sortie attendue. Cette connexion permet de suivre les données qui n'ont pu être traitées pour
quelque raison que ce soit (mauvais type, valeur nulle non définie, etc.).
Trigger connections for a Job : Les connexions de déclenchement définissent la séquence de traitement,
donc aucune donnée n'est gérée via ces connexions. La connexion utilisée va créer une dépendance
entre des Jobs ou sous-Jobs qui seront donc déclenchés les uns après les autres selon la nature du
déclencheur. Les connexions de déclenchement se répartissent en deux catégories : Déclencheurs de
sous-job : On Subjob Ok, On Subjob Error et Run if ; Déclencheurs de composants : On Component Ok,
On Component Error et Run if. OnComponentOK et OnComponentError peuvent être utilisés avec
n’importe quel composant source du sous-Job

• OnSubjobOK : cette connexion est utilisée pour déclencher le sous-Job suivant à condition que
le sous-Job principal se soit terminé sans erreur. Cette connexion est à utiliser uniquement à
partir du composant de démarrage du Job. Ces connexions sont utilisées pour orchestrer les
sous-Jobs formant le Job ou pour dépanner et gérer facilement les erreurs inattendues.
• OnSubjobError : cette connexion est utilisée pour déclencher le sous-Job suivant au cas où le
premier sous-Job (principal) ne se terminerait pas correctement. Ce sous-Job «en cas d'erreur»
permet de signaler le goulot d'étranglement ou de gérer l'erreur si possible.
• OnComponentOK : ne déclenchera le composant cible qu'une fois l'exécution du composant
source terminée sans erreur. Son utilisation principale pourrait être de déclencher un sous-Job
de notification par exemple.
• OnComponentError : déclenchera le sous-Job ou le composant dès qu'une erreur est rencontrée
dans le Job principal.
La principale différence entre OnSubjobOK et OnComponentOK réside dans l'ordre d'exécution du sous-
Job lié. Avec OnSubjobOK, le sous-Job lié démarre uniquement lorsque le sous-Job précédent est
complètement terminé. En revanche, avec OnComponentOK, le sous-Job lié démarre lorsque le
composant précédent se termine. L'ordre d'exécution des sous-Jobs liés par OnComponentOK se situe
dans le cycle d'exécution du sous-Job précédent.
• Run if : déclenche un sous-Job ou un composant, si la condition définie est remplie.

Activation/Désactivation d'un composant ou d'un sous-Job

Vous pouvez activer ou désactiver un sous-Job directement connecté au composant sélectionné. Vous
pouvez également activer ou désactiver un seul composant ainsi que tous les sous-Jobs liés à un
composant Start. Le composant Start est le déclencheur du Job. Il a un fond vert. Lorsqu'un composant
ou un sous-Job est désactivé, vous ne pouvez pas créer ou modifier des liens depuis ou vers celui-ci. De
plus, au moment de l'exécution, aucun code n'est généré pour le composant ou le sous-Job désactivé.
Pour activer ou désactiver un composant, faites un clic droit sur le composant que vous souhaitez activer
ou désactiver, puis sélectionnez l'option correspondante à l'action que vous souhaitez effectuer.
D’autres part, pour activer ou désactiver un sous-Job, cliquez avec le bouton droit sur n'importe quel
composant du sous-Job, puis sélectionnez l'option correspondante à l'action que vous souhaitez
effectuer.

Centralisation des métadonnées pour l'intégration des données

La gestion des métadonnées est l'un des aspects les plus importants du développement de tâches
Talend. Ce dernier fournit une multitude d'assistants pour capturer les métadonnées d'une variété de
sources de données telles que les tables de base de données, les fichiers délimités et les feuilles de calcul

Pr. I.MOUNTASSER 16
ETL avec Talend Open Studio

Excel et les stocke dans son référentiel de métadonnées intégré. Ainsi, le dossier Metadata dans la vue
Repository stocke des informations réutilisables sur les fichiers, bases de données et/ou systèmes dont
vous avez besoin pour créer vos Jobs. Différents assistants correspondants vous aident à stocker ces
informations qui pourront être utilisées ultérieurement pour définir les paramètres de connexion des
composants d'entrée ou de sortie concernés et la description des données appelées « schémas » de
manière centralisée dans le Studio Talend. Les procédures des différents assistants diffèrent légèrement
selon le type de connexion choisi.

Composants tPrejob et tPostjob

Les composants tPrejob et tPostjob sont conçus pour faciliter la gestion de l'exécution des tâches avant
et après un Job donné. Ces composants diffèrent des autres composants dans la mesure où ils ne traitent
pas réellement les données et n'ont aucune propriété de composant à configurer. Une caractéristique
clé de ces composants est qu'ils sont toujours garantis d'être exécutés, même en cas d'échec du Job de
données principal. Par conséquent, ils sont très utiles pour les actions de configuration et de démontage
d'un Job donné.
Pour utiliser ces composants tPrejob et tPostjob, déposez-les simplement dans l'espace de travail de
conception comme vous le feriez avec n'importe quel autre composant, puis connectez le tPrejob à un
composant ou un sous-Job destiné à effectuer une tâche préalable au travail, et le tPostjob à un
composant ou à un sous-Job destiné à effectuer une tâche post-tâche, à l'aide de connexions Trigger.
Un carré orange sur les parties pré- et post-job indique qu'il s'agit de différents types de sous-Jobs.
Les tâches qui nécessitent l'utilisation d'un composant tPrejob incluent :
→ Chargement des informations contextuelles requises pour l'exécution du sous-Job.
→ Ouverture d'une connexion à une base de données.
→ S'assurer qu'un fichier existe.
Les tâches qui nécessitent l'utilisation d'un composant tPostjob incluent :
→ Nettoyage des fichiers temporaires créés lors du traitement du Job de données principales.
→ Fermeture d'une connexion à une base de données ou d'une connexion à un service externe.
→ Toute tâche devant être exécutée, même si le Job ou les sous-Jobs précédents ont échoué.

Pr. I.MOUNTASSER 17