Questions et réponses d'entretien Talend : ETL, tMap, contexte et débogage

Les entretiens Talend évaluent généralement deux choses : votre capacité à concevoir un job d'intégration de données pertinent, et votre capacité à identifier pourquoi un job est lent ou en panne. Attendez-vous à des questions sur les briques de base (composants, sous-jobs, tMap, variables de contexte), puis à des mises en situation sur les erreurs, les performances et le déploiement.

Talend fait désormais partie de Qlik, et la gamme de produits a évolué au fil des années. Consultez la fiche de poste pour voir si l'équipe utilise Talend Studio avec une licence d'intégration de données ou big data, Talend Cloud, ou une ancienne installation open source. Les concepts ci-dessous s'appliquent à toutes ces versions, mais les noms de composants et les détails de déploiement diffèrent.

Les questions que vous entendrez le plus souvent

Qu'est-ce que Talend et comment génère-t-il du code ?

Talend est un outil d'intégration de données. Vous construisez des jobs sur un canevas en connectant des composants, et Talend Studio génère du code Java à partir de la conception. Lorsque vous exécutez un job, ce code est compilé et exécuté. C'est important en entretien, car cela explique pourquoi vous pouvez insérer du Java personnalisé dans un composant tJava ou tJavaRow, pourquoi les routines sont des classes Java, et pourquoi les paramètres de mémoire sont des paramètres JVM.

Quelle est la différence entre un job, un sous-job et un joblet ?

Un job est le workflow complet. Un sous-job est un groupe de composants reliés par des liens de flux de données, et un job est généralement composé de plusieurs sous-jobs reliés par des déclencheurs. Un joblet est un groupe de composants réutilisable, enregistré une fois et utilisé dans de nombreux jobs, à la manière d'une fonction.

Quelle est la différence entre OnSubjobOk et OnComponentOk ?

Ce sont tous deux des liens de déclenchement qui s'exécutent après un succès. OnSubjobOk se déclenche lorsque le sous-job entier se termine avec succès. OnComponentOk se déclenche dès qu'un seul composant se termine, ce qui peut arriver au milieu d'un sous-job. Il existe aussi OnSubjobError et OnComponentError pour les échecs, ainsi que Run if pour les chemins conditionnels.

À quoi sert tMap ?

tMap est le principal composant de transformation. Il joint un flux principal à un ou plusieurs flux de recherche, applique des expressions, filtre des lignes et envoie les données vers plusieurs sorties. Les fonctionnalités clés à mentionner :

• Jointure interne et jointure externe gauche sur les lookups
• Sorties de rejet pour les lignes qui échouent à une jointure ou à un filtre
• Expressions de filtre sur les entrées et les sorties
• Variables, pour qu'un calcul soit écrit une fois et réutilisé
• Options du modèle de lookup : chargement unique, rechargement à chaque ligne, ou rechargement à chaque ligne avec une clé

Comment gérer un lookup volumineux dans tMap ?

Par défaut, les données de lookup sont chargées en mémoire. Pour un lookup volumineux, activez « Store temp data » afin que tMap les écrive sur disque, augmentez la mémoire de la JVM, ou évitez le problème en réalisant la jointure directement dans la base de données. Vous pouvez aussi utiliser « Reload at each row » pour un lookup qui dépend de la ligne entrante, au prix d'une requête par ligne, ce qui ne convient donc qu'à de petits flux principaux.

Que sont les variables de contexte et pourquoi les utiliser ?

Les variables de contexte contiennent des valeurs qui changent d'un environnement à l'autre, comme les noms d'hôtes, les schémas, les chemins de fichiers et les identifiants. Vous les définissez une fois, les regroupez dans des contextes (Dev, Test, Prod), et sélectionnez le contexte à l'exécution. Une bonne réponse ajoute que les mots de passe ne doivent pas être stockés en clair dans le job et que le même job exporté doit pouvoir s'exécuter dans chaque environnement en ne changeant que le fichier de contexte.

Comment transmettre des valeurs entre les jobs ?

Avec tRunJob, vous pouvez passer des paramètres de contexte à un job enfant, et un job enfant peut renvoyer des valeurs au parent via le composant tBufferOutput ou des variables globales. Au sein d'un même job, les valeurs sont stockées dans le globalMap, une map Java que vous lisez avec (String) globalMap.get("key") et dans laquelle vous écrivez avec globalMap.put.

Quelle est la différence entre tFlowToIterate et un flux normal ?

Un flux normal fait passer toutes les lignes ensemble à travers les composants. tFlowToIterate transforme chaque ligne en une itération, de sorte que les composants suivants s'exécutent une fois par ligne. C'est utile pour boucler sur une liste de noms de fichiers ou de tables, mais c'est lent sur de gros volumes de données car chaque itération démarre un sous-job.

Comment gérer les erreurs dans Talend ?

Mentionnez plusieurs niveaux :

1. Les liens de déclenchement tels que OnSubjobError et OnComponentError pour envoyer les échecs vers un chemin séparé
2. tDie pour arrêter le job avec un code d'erreur, et tWarn pour journaliser un avertissement
3. tLogCatcher pour collecter les avertissements et erreurs émis par tDie, tWarn et les exceptions Java
4. Les liens de rejet sur des composants tels que tMap et les composants de sortie de base de données pour les lignes invalides
5. tPreJob et tPostJob pour ouvrir et toujours libérer les ressources

Comment débogueriez-vous un job en échec ?

Exécutez-le en mode Debug, ou ajoutez tLogRow pour visualiser les données entre les composants. Vérifiez l'erreur exacte et le nom du composant dans la console, puis contrôlez les paramètres de connexion et les valeurs de contexte utilisées. Pour les problèmes de données, envoyez les rejets vers un fichier et inspectez-les. L'utilisation de tStatCatcher ou des statistiques du job permet aussi de voir le nombre de lignes et les temps par composant.

Questions sur les performances

Un job qui charge un million de lignes est lent. Que vérifiez-vous ?

1. Où passe le temps. Le nombre de lignes et les durées par composant révèlent le goulot d'étranglement.
2. Si le travail a sa place dans la base de données. Les jointures et les agrégations sont souvent plus rapides en SQL que dans un tMap.
3. La taille des commits. Valider à chaque ligne est lent, il faut donc committer par lots.
4. Les composants bulk. Beaucoup de bases de données disposent de composants de chargement en masse bien plus rapides que les insertions ligne par ligne.
5. Les lookups tMap. Un gros lookup en mémoire peut provoquer des pauses de garbage collection ou des erreurs de mémoire insuffisante.
6. Les paramètres de la JVM. Augmentez le heap maximum (la valeur Xmx) si la mémoire est la limite.
7. Le parallélisme. Certains composants et jobs peuvent s'exécuter en parallèle, mais uniquement quand le travail ne dépend pas de l'ordre.

Comment ne charger que les enregistrements nouveaux ou modifiés ?

Conservez un repère haut comme un timestamp de dernière modification ou un ID croissant, stockez-le dans une table de contrôle ou une variable de contexte, et n'extrayez que les lignes au-dessus. Pour les mises à jour dans la cible, comparez les clés et utilisez des actions insert ou update, ou une instruction merge dans la base de données. Pour les suppressions, vous aurez peut-être besoin d'une comparaison complète des clés ou d'un flux de change data capture.

Comment supprimer les doublons ?

tUniqRow supprime les doublons selon les colonnes sélectionnées et peut envoyer les doublons vers une sortie séparée. tAggregateRow peut regrouper et choisir une valeur. Pour de très gros volumes, il est souvent préférable de le faire dans la base de données avec une fonction de fenêtrage.

Composants à connaître de nom

Déploiement et planification

Soyez prêt à décrire comment vous faites passer un job de Studio en production. Les étapes typiques consistent à compiler le job en package autonome ou à le publier dans un référentiel, à définir le contexte de production, puis à le planifier avec l'ordonnanceur de l'équipe, que ce soit l'outil de gestion de Talend, cron ou un autre orchestrateur. La gestion de versions, les normes de nommage et la documentation des jobs font toutes partie d'une bonne réponse.

Un scénario à travailler

« Vous recevez un fichier client quotidien. Certaines lignes ont des emails manquants et certains clients existent déjà dans l'entrepôt. Concevez le job. »

Un bon plan :

1. Lire le fichier avec tFileInputDelimited et un schéma défini.
2. Dans tMap, filtrer les lignes dont l'email est manquant vers un fichier de rejet et rechercher la clé client dans la table de l'entrepôt.
3. Envoyer les clients existants vers un chemin de mise à jour et les nouveaux vers un chemin d'insertion.
4. Écrire dans la base de données par lots avec une taille de commit adaptée.
5. Utiliser tLogCatcher et une table de contrôle pour journaliser le nombre de lignes et les erreurs de chaque exécution.
6. Utiliser une variable de contexte pour le chemin du fichier et la connexion à la base de données afin que le même job tourne dans tous les environnements.

Énoncez vos hypothèses à voix haute, comme la taille du fichier et la nécessité de conserver un historique, car les recruteurs veulent voir comment vous raisonnez.

Comment se préparer

Construisez un petit job de bout en bout si vous le pouvez : lire un fichier, le joindre à une table dans tMap, gérer les rejets et écrire dans une base de données. Sachez expliquer ce que vous feriez quand il échoue à la ligne 500 000. Ayez en tête un ou deux exemples réels tirés de votre expérience, avec des chiffres comme le nombre de lignes par exécution ou le temps gagné. Pour des sujets connexes d'ingénierie des données, consultez nos guides sur les entretiens Databricks et Snowflake.

S'entraîner à voix haute aide. Utilisez un entretien simulé pour expliquer la conception d'un job, puis relisez la transcription pour repérer les étapes que votre explication a sautées. Respectez les règles de l'employeur sur les outils d'IA lors de tout entretien en direct.