Talend Interviewvragen en Antwoorden: ETL, tMap, Context en Debugging

Talend-interviews testen meestal twee dingen: of je een verstandige data-integratietaak kunt ontwerpen, en of je kunt achterhalen waarom een taak traag is of niet werkt. Verwacht vragen over de bouwstenen (componenten, subjobs, tMap, contextvariabelen), en daarna scenario's over fouten, prestaties en deployment.

Talend maakt nu deel uit van Qlik, en de productlijn is in de loop der jaren veranderd. Controleer de vacaturetekst om te zien of het team Talend Studio gebruikt met een data-integratie- of big data-licentie, Talend Cloud, of een oudere open source-opstelling. De onderstaande concepten gelden voor allemaal, maar componentnamen en deploymentdetails verschillen.

De vragen die je het vaakst zult horen

Wat is Talend en hoe genereert het code?

Talend is een data-integratietool. Je bouwt jobs op een canvas door componenten met elkaar te verbinden, en Talend Studio genereert Java-code op basis van het ontwerp. Wanneer je een job uitvoert, wordt die code gecompileerd en uitgevoerd. Dit is belangrijk in interviews, omdat het verklaart waarom je aangepaste Java kunt gebruiken in een tJava- of tJavaRow-component, waarom routines Java-klassen zijn, en waarom geheugeninstellingen JVM-instellingen zijn.

Wat is het verschil tussen een job, een subjob en een joblet?

Een job is de hele workflow. Een subjob is een groep componenten die via dataflow-links met elkaar verbonden zijn, en een job bestaat meestal uit meerdere subjobs die via triggers aan elkaar gekoppeld zijn. Een joblet is een herbruikbare groep componenten die één keer wordt opgeslagen en in veel jobs wordt gebruikt, zoals een functie.

Wat is het verschil tussen OnSubjobOk en OnComponentOk?

Beide zijn trigger-links die worden uitgevoerd nadat iets is geslaagd. OnSubjobOk wordt geactiveerd wanneer de hele subjob succesvol is afgerond. OnComponentOk wordt geactiveerd zodra één component klaar is, wat midden in een subjob kan zijn. Er zijn ook OnSubjobError en OnComponentError voor fouten, plus Run if voor voorwaardelijke paden.

Wat doet tMap?

tMap is de belangrijkste transformatiecomponent. Het voegt een hoofdflow samen met een of meer lookup-flows, past expressies toe, filtert rijen en stuurt data naar meerdere outputs. Belangrijke functies om te noemen:

• Inner join en left outer join op lookups
• Reject-outputs voor rijen die niet door een join of filter komen
• Filterexpressies op inputs en outputs
• Variabelen, zodat een berekening één keer wordt geschreven en hergebruikt
• Lookup-modelopties: load once, reload at each row, of reload at each row with a key

Hoe ga je om met een grote lookup in tMap?

Standaard wordt de lookup-data in het geheugen geladen. Voor een grote lookup stel je "Store temp data" in, zodat tMap de data naar schijf schrijft, verhoog je het JVM-geheugen, of vermijd je het probleem door in de database te joinen. Je kunt ook "Reload at each row" gebruiken voor een lookup die afhankelijk is van de inkomende rij, ten koste van een query per rij, dus dat is alleen geschikt voor kleine hoofdflows.

Wat zijn contextvariabelen en waarom gebruik je ze?

Contextvariabelen bevatten waarden die per omgeving veranderen, zoals hostnames, schema's, bestandspaden en inloggegevens. Je definieert ze één keer, groepeert ze in contexten (Dev, Test, Prod), en selecteert de context tijdens de uitvoering. Een goed antwoord voegt toe dat wachtwoorden niet als platte tekst in de job mogen worden opgeslagen en dat dezelfde geëxporteerde job in elke omgeving moet kunnen draaien, waarbij alleen het contextbestand verandert.

Hoe geef je waarden door tussen jobs?

Met tRunJob kun je contextparameters doorgeven aan een child-job, en een child-job kan waarden teruggeven aan de parent met behulp van de tBufferOutput-component of global variables. Binnen één job worden waarden opgeslagen in de globalMap, een Java-map die je leest met (String) globalMap.get("key") en schrijft met globalMap.put.

Wat is het verschil tussen tFlowToIterate en een normale flow?

Een normale flow verplaatst alle rijen samen door de componenten. tFlowToIterate maakt van elke rij een iteratie, zodat de volgende componenten één keer per rij worden uitgevoerd. Het is handig voor het doorlopen van een lijst met bestandsnamen of tabellen, maar het is traag voor grote datasets omdat elke iteratie een subjob start.

Hoe ga je om met fouten in Talend?

Noem meerdere lagen:

1. Trigger-links zoals OnSubjobError en OnComponentError om fouten via een apart pad te versturen
2. tDie om de job met een foutcode te stoppen, en tWarn om een waarschuwing te loggen
3. tLogCatcher om waarschuwingen en fouten te verzamelen die door tDie, tWarn en Java-exceptions worden gegenereerd
4. Reject-links op componenten zoals tMap en database-outputcomponenten voor foutieve rijen
5. tPreJob en tPostJob om resources te openen en altijd op te ruimen

Hoe zou je een falende job debuggen?

Voer deze uit in Debug-modus, of voeg tLogRow toe om de data tussen componenten te zien. Controleer de exacte fout en de componentnaam in de console, en controleer vervolgens de verbindingsinstellingen en de gebruikte contextwaarden. Voor dataproblemen stuur je rejects naar een bestand en inspecteer je ze. Het gebruik van tStatCatcher of de statistieken van de job toont ook het aantal rijen en de tijden per component.

Performance-vragen

Een job die een miljoen rijen laadt, is traag. Wat controleer je?

1. Waar de tijd naartoe gaat. Rijtellingen en timings per component laten de bottleneck zien.
2. Of het werk wel in de database thuishoort. Joins en aggregaties zijn vaak sneller in SQL dan in tMap.
3. Commit-grootte. Bij elke rij committen is traag, dus commit in batches.
4. Bulk-componenten. Veel databases hebben bulk load-componenten die veel sneller zijn dan rij-voor-rij inserts.
5. tMap-lookups. Een grote in-memory lookup kan garbage collection-pauzes of out-of-memory-fouten veroorzaken.
6. JVM-instellingen. Verhoog de maximale heap (de Xmx-waarde) als geheugen de beperkende factor is.
7. Parallellisme. Sommige componenten en jobs kunnen parallel draaien, maar alleen wanneer het werk niet afhankelijk is van de volgorde.

Hoe laad je alleen nieuwe of gewijzigde records?

Houd een high-water mark bij, zoals een last-modified timestamp of een oplopend ID, sla die op in een control table of contextvariabele, en extraheer alleen rijen daarboven. Voor updates in het doel vergelijk je keys en gebruik je insert- of update-acties, of je gebruikt een merge statement in de database. Voor deletes heb je mogelijk een volledige key-vergelijking nodig of een change data capture-feed.

Hoe verwijder je duplicaten?

tUniqRow verwijdert duplicaten op basis van geselecteerde kolommen en kan duplicaten naar een aparte output sturen. tAggregateRow kan groeperen en een waarde kiezen. Voor enorme datasets is het vaak beter om dit in de database te doen met een window function.

Componenten die je bij naam moet kennen

Deployment en scheduling

Wees klaar om te beschrijven hoe je een job van Studio naar productie brengt. Typische stappen zijn het bouwen van de job als een standalone package of het publiceren naar een repository, het instellen van de productiecontext, en het inplannen met de scheduler van het team, of dat nu Talend's eigen managementtool is, cron, of een andere orchestrator. Versiebeheer, naamgevingsstandaarden en documentatie voor jobs horen allemaal bij een goed antwoord.

Een scenario om te oefenen

"Je ontvangt dagelijks een klantbestand. Sommige rijen hebben ontbrekende e-mails en sommige klanten bestaan al in het warehouse. Ontwerp de job."

Een sterke opzet:

1. Lees het bestand met tFileInputDelimited en een gedefinieerd schema.
2. Filter in tMap rijen met ontbrekende e-mails naar een reject-bestand en zoek de klantsleutel op in de warehouse-tabel.
3. Stuur bestaande klanten naar een update-pad en nieuwe naar een insert-pad.
4. Schrijf in batches naar de database met een passende commit-grootte.
5. Gebruik tLogCatcher en een control table om rijtellingen en fouten per run te loggen.
6. Gebruik een contextvariabele voor het bestandspad en de databaseverbinding, zodat dezelfde job in elke omgeving draait.

Spreek je aannames hardop uit, zoals bestandsgrootte en of historie bewaard moet blijven, want interviewers willen zien hoe je redeneert.

Hoe je je voorbereidt

Bouw indien mogelijk een kleine job end-to-end: lees een bestand, join het met een tabel in tMap, handel rejects af en schrijf naar een database. Zorg dat je kunt uitleggen wat je doet wanneer het misgaat bij rij 500.000. Ken een of twee echte voorbeelden uit je ervaring, met cijfers zoals rijen per run of bespaarde tijd. Voor gerelateerde data-engineering-onderwerpen kun je onze gidsen bekijken over Databricks en Snowflake-interviews.

Hardop oefenen helpt. Gebruik een mock interview om een jobontwerp uit te leggen en lees daarna het transcript om te zien waar je uitleg stappen oversloeg. Volg de regels van de werkgever over AI-tools in elk live interview.