API Integration

Talend ESB Studio User Guide

EnrichVersion: 7.2
EnrichProdName: Talend ESB
EnrichPlatform: Talend Studio
task: Design and Development

What is Talend Studio?
Projects and Business Models
Working with projects
Creating a project
Creating a project at initial Studio launch
Creating a new project after initial Studio launch
Creating a sandbox project
Importing a demo project
Importing a demo project as a separate project
Importing a demo project into your current project
Installing example files in the Data Integration demo project
Importing local projects
Importing a single project
Importing multiple projects
Opening a remote project
Exporting a project
Working collaboratively on project items
Lock principle
Locking/unlocking an item (default)
Accessing locked items (default)
Lock types
Automatic lock mode
Semi-automatic lock mode
Manual lock mode
Accessing items of a remote project in offline mode
Handling changes not committed to the SVN or Git
Handling uncommitted items when prompted (SVN only)
Handling uncommitted items when prompted (Git only)
Logging information on edited items
Deleting shared items
Working with project branches and tags
Creating a local branch from the Studio (Git only)
Creating a new branch based on a selected source
Checking out a remote branch as a local one
Pushing changes on a local branch to the remote end (Git only)
Updating a local branch (Git only)
Reverting a local branch to the previous update state (Git only)
Deleting a local branch (Git only)
Creating a tag for a project
If you are working on an SVN managed project:
If you are working on a Git managed project
Switching between branches or tags
On SVN managed project
On Git managed project
Viewing the project history specific to a branch or tag (Git only)
Resolving conflicts between branches (Git only)
Resolving conflicts in compare editors
Job Compare editor
EMF Compare editor
Text Compare editor
Merging remote branches (Git only)
Defining project references
Working with business models
What is a Business Model
Creating a Business Model
Modeling a Business Model
Shapes
Connecting shapes
Commenting and arrange a model
Adding a note or free text
Arranging the model view
Business Models
Appearance tab
Rulers and Grid tab
Assignment tab
Assigning repository elements to a Business Model
Licenses
Managing licenses in the Studio
Checking/changing the license for the Studio
Licenses and perspectives in the Studio
Data Services
Talend ESB functional architecture
Designing Jobs and Routes
What is a Job design?
Getting started with a basic Job
Creating a Job
Adding components to the Job
Dropping the first component from the Palette
Adding the second component by typing on the design workspace
Adding an output component by dragging from an input one
Connecting the components together
Right-click and click again
Drag and drop
Configuring the components
Configuring the tFileInputDelimited component
Configuring the tLogRow component
Configuring the tFileOutputDelimited component
Executing the Job
Creating a Job from a template
Outputting data from a file to a database table and vice versa
Outputting data from one database table to another
Outputting data from a file to a Joblet in a specific format
Creating a Job using a Job creation API
What is a Route
Getting started with a basic Route
Creating a Route
Adding components to the Route
Adding the first Route component from the Palette
Typing on the design workspace to add the second Route component
Dragging from an input Route component to add an output one
Connecting the Route components
Route link by right-click and click
Drag and drop to create the Route link
Configuring the components
Executing the Route
Working with components
Adding a component between two connected components
Dropping the component from the Palette onto the connection
Adding the component by typing on the connection
Adding the component to the design workspace and moving the existing connection
Defining component properties
Basic Settings tab
Setting a built-in schema in a Job
Setting a repository schema in a Job
Using a repository schema partially in a Job
Setting a field dynamically (Ctrl+Space bar)
Advanced settings tab
Measuring data flows
Dynamic settings tab of components in a Job
Dynamic schema
Defining dynamic schema columns
Mapping dynamic columns
View tab
Documentation tab
Finding Jobs containing a specific component
Setting default values in the schema of a component in a Job
Using Camel components in a Route
Using the tPrejob and tPostjob components
Installing and sharing custom components created using Talend Component Kit
Downloading/uploading Talend Community components
Installing community components from Talend Exchange
Reinstalling or update community components
Reviewing and rate a community component
Uploading a component you created to Talend Exchange
Managing components you uploaded to Talend Exchange
Using connections in a Job
Connection types
Row connection
Main
Lookup
Filter
Rejects
ErrorReject
Output
Uniques/Duplicates
Multiple Input/Output
Combine
Iterate connection
Trigger connections
Link connection
Defining connection settings
Row connection settings
Iterate connection settings
Trigger connection settings
Run if connection settings
Adding a conditional breakpoint
Using connections in a Route
Route connection types
Row connections for a Route
route
try
catch
finally
Trigger connections
when
otherwise
How to define connection settings of a Route
Catch connection settings
When connection settings
Using contexts and variables
Defining context variables for a Job or Route
Defining context variables in the Contexts view
Defining contexts
Defining variables
Defining variables from the Component view
Centralizing context variables in the Repository
Creating a context group and define context variables in it
Creating the context group and contexts
Defining context variables
Adding a built-in context variable to the Repository
Creating a context from a Metadata
Applying Repository context variables to a Job or Route
Dropping a context group onto a Job or Route
Applying context variables to a Job or Route using the context button
Using variables in a Job or Route
Running a Job or Route in a selected context
Handling Jobs: advanced subjects
Creating queries using the SQLBuilder
Comparing database structures
Creating a query
Storing a query in the repository
Using resources in Jobs
Creating a resource
Using a resource in a Job
Using the Use Output Stream feature
Handling Jobs: miscellaneous subjects
Using folders
Sharing a database connection
Handling error icons on components or Jobs
Warnings and error icons on components
Error icons on Jobs
Adding notes to a Job design
Viewing in-process data
Result Data Viewer
Raw Data Viewer
Displaying the code or the outline of your Job
Outline
Code viewer
Managing the subJob display
Formatting subJobs
Collapsing the subJobs
Removing the subJob background color
Defining options on the Job view
Automating the use of statistics & logs
Using the features in the Extra tab
Error handling in Talend Studio
Error handling with components
Using tAssert and tAssertCatcher for error handling
Using tChronometerStart and tChronometerStop for error handling
Using tDie, tWarn and tLogCatcher for error handling
Using tFlowMeter and tFlowMeterCatcher for error handling
Using tLogRow for error handling
Error handling with connections
Error handling at design
Handling Routes: Advanced subjects
Using Route Resources
Creating a Route Resource
Managing Route Resource versions
Using a Route Resource
Using Beans
Creating a Bean
Using a Bean
Using Spring configuration
Desiging services
What is a Service
Getting started with a basic Service
Creating a Service
Editing a WSDL file
Adding a Service
Adding a port to a Service
Setting a binding
Creating a new binding
Reusing an existing binding
Setting a port type
Creating a new port type for a binding
Reusing an existing port type
Adding an operation
Adding a message
Creating a new message
Reusing an existing message
Adding a part to a message
Creating a new type for your WSDL file
Assigning a data service Job to a service operation
Monitoring the log messages of a data service Job
Exporting a Service for deployment
Handling Services: miscellaneous subjects
Importing WSDL schemas
Setting the Runtime options
API Integration
API integration overview
Using metadata for API Specifications
Creating a new REST API metadata from file
Using REST metadata with Jobs and Routes
Designing a Joblet
What is a Joblet
Creating a Joblet from scratch
Creating a Joblet from a Job
Using a Joblet in a Job
Using a Joblet in the beginning of a Job
Launching a Joblet
Using triggers in a Joblet
Launching the Joblet in a Job
Editing a Joblet
Editing the Joblet in the Job
Editing the Joblet in a new tab view
Organizing Joblets
Applying a context variable to a Joblet
Setting up routine dependencies on a Joblet
Designing a Routelet
What is a Routelet
Creating a Routelet from scratch
Using a Routelet in a Route
Editing a Routelet
Organizing Routelets
Applying a context variable to a Routelet
Managing Jobs , Routes and Services
Activating/Deactivating a component or a subJob or a Route
Activate or deactivate a component
Activate or deactivate a subJob
Activate or deactivate all linked subJobs
Activate or deactivate a Route
Importing/exporting items and building Routes and Jobs
Importing items
Building Jobs
Building a Job as a standalone Job
Building a Job as an OSGI Bundle For ESB
Building a Job as a Microservice (Spring-boot) for ESB
Building Routes
Building a Route to an ESB Runtime KAR file
Building a Route to a Spring-boot based ESB Microservice
Editing Route Manifest
Exporting items
Changing context parameters in Jobs and Routes
Publishing to the Artifact Repository
Customizing deployment of a Job, Route or Service
Managing repository items
Handling updates in repository items
Modifying a repository item
Updating impacted Jobs automatically
Updating impacted Jobs manually
Analyzing repository items
Impact analysis
Data lineage
Exporting the results of impact analysis/data lineage to HTML
Exporting the results of impact analysis/data lineage to XML
Searching a Job in the repository
Managing Job and Route versions
Updating the version of an inactive Job or Route
Updating the version of an active Job or Route
Working on different versions of a Job or Route
Removing a version of a Job or Route
Documenting a Job or a Route
Generating HTML documentation
Autogenerating documentation
Updating the documentation on the spot
Working with referenced projects
Accessing items in the referenced projects
Using items from referenced projects
Comparing Jobs
Running Jobs and Routes
Running a Job or Route in normal mode
Running a Job or Route in Java Debug mode
Running a Job in Traces Debug mode
Row by row monitoring
Breakpoint monitoring
Setting advanced execution settings
Displaying Statistics
Displaying the execution time and other options
Displaying special characters in the console
Specifying the limits of VM memory for a Job or Route
Customizing log4j output level at runtime
Showing JVM resource usage during Job or Route execution
Deploying a Job on SpagoBI server (deprecated)
Creating a SpagoBI server entry
Editing or remove a SpagoBI server entry
Deploying your Jobs on a SpagoBI server
Running a Microservice Route
An example of running a Microservice Route using external Log4j configuration
Running a Route or Data Service Job in local Talend Runtime Test Container
Using parallelization to optimize Job performance
Executing multiple subJobs in parallel
Launching parallel iterations to read data
Orchestrating parallel executions of subJobs
Writing data in parallel
Testing Jobs and Services using test cases
Creating a test case
Setting up a test case
Adding test instances
Defining context variables for the test data
Defining embedded data sets
Executing test cases
Running a test case from the Run view
Running a test case from the Test Cases view
Running a test case or all test cases of a Job from the Repository tree view
Managing test cases
Testing Routes using test cases
Creating a Route test case
Setting up a Route test case
Configuring ProducerTemplate
Adding Route test instances
Defining context variables for the Route test data
Defining embedded data sets for a Route
Executing Route test cases
Running a Route test case from the Test Cases view
Running a Route test case from the Repository tree view
Managing Route test cases
An example of XML payload testing
Building the Route
Testing the Route
Creating the test case
Configuring the test case
Executing the test case
Managing Jobs on different branches and tags
Copying a Job to a branch
Reverting a project item on a tag
Mapping data flows
Map editor interfaces
tMap operation
Setting the input flow in the Map Editor
Filling in Input tables with a schema
Main and Lookup table content
Variables
Using Explicit Join
Defining the match model for an explicit Join
Unique Match
First Match
All Matches
Using Inner Join
Using the All Rows option
Filtering an input flow
Removing input entries from table
Mapping variables
Accessing global or context variables
Removing variables
Working with expressions
Accessing the expression editor
Writing code using the Expression Builder
Editing individual expressions
Setting expressions for multiple output columns simultaneously
Mapping the Output setting
Setting automatic input-output mappings
Creating complex expressions
Filters
Output rejection
Lookup Inner Join rejection
Removing Output entries
Handling errors
Setting schemas in the Map Editor
Retrieving the schema structure from the Repository
Searching schema columns
Using the Schema Editor
Enabling automatic data type conversion
Defining rules to override the default conversion behavior
Solving memory limitation issues in tMap use
Handling Lookups
Setting the loading mode of a lookup flow
Reloading data at each row
Loading multiple lookup flows in parallel
Previewing data
tXMLMap operation
Using the document type to create the XML tree
Setting up the Document type
Importing the XML tree structure from XML and XSD files
Importing the XML tree structure from an XML file
Importing the XML tree structure from an XSD file
Importing the XML tree structure from the Repository
Setting or resetting a loop element for an imported XML structure
Adding a sub-element or an attribute to an XML tree structure
Deleting an element or an attribute from the XML tree structure
Managing a namespace
Defining a namespace
Modifying the default value of a namespace
Deleting a namespace
Grouping the output data
Setting a group element
Revoking a defined group element
Aggregating the output data
Defining the output mode
Outputing elements into one document
Managing empty element in Map editor
Defining the sequence of multiple input loops
Editing the XML tree schema
Change Data Capture (CDC)
CDC architectural overview
Trigger mode
CDC Redo/Archive log mode
XStream mode
CDC: a publish/subscribe principle
Setting up a CDC environment
Setting up CDC in Trigger mode
Configuring CDC in Trigger mode
Step 1: Set up a publisher
Step 2: Identify the source table
Step 3: Create the subscriber(s) table
Step 4: Subscribe to the source table and activate the subscription
Extracting change data in Trigger mode
Setting up CDC in Oracle Redo/Archive log mode
Prerequisites for the Oracle Redo/Archive log mode
Activate the archive log mode in Oracle
Set up CDC in Oracle
Configuring CDC in Oracle Redo/Archive log mode
Step 1: Set up a publisher in Oracle Redo/Archive log mode
Step 2: Identify the source table in Oracle Redo/Archive log mode
Step 3: Retrieve and process changes in Oracle Redo/Archive log mode
Step 4: Create the change table, subscribe to the source table and activate the subscription
Extracting change data modified in Oracle Redo/Archive log mode
Setting up CDC in Oracle XStream mode
Prerequisites for the XStream mode
Activate the archive log mode in Oracle XStream mode
Open all PDBs for a CDB in Oracle
Configure an XStream administrator
Configuring CDC using XStream mode
Configure XStream Out in Talend Studio
Configure XStream In in Talend Studio
Extracting and synchronizing data changes in XStream mode
Setting up CDC in Redo/Archive log mode (journal) for AS/400
The prerequisites on AS/400
Configuring CDC in AS/400 journal mode
Step 1: Set up a publisher in AS/400 journal mode
Step 2: Identify the source table in AS/400 journal mode
Step 3: Create the subscriber(s) table in AS/400 journal mode
Step 4: Finalize the subscription in AS/400 journal mode
Extracting the change data modified in AS/400 journal mode
Prerequisites for reusing a migrated CDC environment
Database support for CDC
Centralizing metadata for Data Integration
Objectives
Centralizing database metadata
Setting up a database connection
Defining general properties
Defining connection parameters
Retrieving table schemas
Filtering database objects
Filtering database tables based on their names
Filtering database objects using an SQL query
Selecting tables and defining table schemas
Centralizing JDBC metadata
Creating a JDBC connection and importing a database driver
Completing the JDCB connection details
Retrieving table schemas
Centralizing SAS metadata
Setting up a SAS connection
Retrieving SAS table schemas
Centralizing SAP metadata
Setting up an SAP connection
Retrieving SAP tables
Retrieving SAP Business Content Extractors
Retrieving an SAP function
Retrieving SAP BW objects metadata
Creating a file from SAP IDOC
Centralizing File Delimited metadata
Defining the general properties
Defining the file path and format
Defining the file parsing parameters
Checking and customizing the file schema
Centralizing File Positional metadata
Defining the general properties of the File Positional connection
Defining the file path, format and marker positions
Defining the parsing parameters of your positional file
Checking and customizing the schema of your positional file
Centralizing File Regex metadata
Defining the general properties of the File Regex connection
Defining the path and format of your Regex file
Defining the parsing parameters of your Regex file
Checking and customizing the schema of your Regex file
Centralizing XML file metadata
Setting up XML metadata for an input file
Defining the general properties of the File XML connection
Setting the type of metadata (input)
Uploading an XML file
Uploading an XSD file
Defining the schema
Finalizing the end schema
Setting up XML metadata for an output file
Defining the general properties of the File XML connection for an output file
Setting the type of metadata (output)
Defining the output file structure using an existing XML file
Defining the output file structure using an XSD file
Defining the schema of your output file
Finalizing the end schema of your output file
Centralizing File Excel metadata
Defining the general properties of the File Excel connection
Loading the file
Parsing the file
Finalizing the end schema of your Excel file
Centralizing File LDIF metadata
Centralizing JSON file metadata
Setting up JSON metadata for an input file
Defining the general properties of the File JSON connection
Setting the type of metadata and loading the input file
Defining the schema of your JSON file
Finalizing the schema of your JSON file
Setting up JSON metadata for an output file
Defining general properties of the File JSON connection for an output file
Setting the type of metadata and loading the template JSON file
Defining the JSON schema of your output file
Finalizing the end schema JSON of your output file
Centralizing LDAP connection metadata
Defining the general properties of the LDAP connection
Defining the server connection
Configuring LDAP access parameters
Defining the schema of your LDAP directory
Finalizing the end schema of your LDAP directory
Centralizing Azure Storage metadata
Centralizing Data Stewardship metadata
Centralizing Google Drive metadata
Centralizing Marketo metadata
Centralizing Salesforce metadata
Centralizing Snowflake metadata
Setting up a generic schema
Setting up a generic schema from scratch
Setting up a generic schema from an XML file
Saving a component schema as a generic schema
Centralizing MDM metadata
Setting up the connection
Defining MDM schema
Defining Input MDM schema
Retrieve entity values for an MDM connection
Modifying the created schema
Defining output MDM schema
Defining Receive MDM schema
Managing a survivorship rule package
Viewing or editing a survivorship rule item
The validation step item
The rule package item
The validation flow item
Centralizing Embedded Rules (Drools)
Defining the general properties of the embedded rule
Uploading or creating a file
Creating a rule file
Connecting to an existing rule file
Centralizing Web Service metadata
Setting up a simple schema
Defining general properties of the simple Web Service schema
Selecting the type of schema (Simple)
Specifying the URI and method
Finalizing the end schema (Simple WSDL)
Setting up an advanced schema
Defining general properties of the advanced Web Service schema
Selecting the type of schema (Advanced)
Defining the port name and operation
Defining the input schemas and mappings
Defining the output schemas and mappings
Finalizing the end schema (Advanced WebService)
Discovering Web services using the Web Service Explorer
Centralizing an FTP connection
Defining the general properties of the connection FTP
Connecting to an FTP server
Working with Hierarchical Mapper
Centralizing UN/EDIFACT metadata
Defining the general properties of the UN/EDIFACT schema
Setting the UN/EDIFACT standard and release
Mapping the schema UN/EDIFACT
Finalizing the end schema UN/EDIFACT
Exporting metadata as context and reusing context parameters to set up a connection
Exporting connection details as context variables
Using variables of an existing context group to set up a connection
Importing metadata from a CSV file
Importing database metadata
Importing delimited file metadata
Using centralized metadata in a Job
Using routines
Managing routines
What are routines
Accessing the System Routines
Customizing the system routines
Managing user routines
Creating user routines
Editing user routines
Editing user routine libraries
Calling a routine from a Job
Use case: Creating a file for the current date
Use case: Encrypting a password in Talend Studio
Creating a routine
Validating password transformation using a demo Job
Troubleshooting password encryption
Use case: Defining a variable accessible to multiple Jobs
Creating a routine and declaring a static variable
Setting up the child Jobs
Setting up the parent Job
Executing the Job
System routines
Numeric Routines
Creating a Sequence
Converting an Implied Decimal
Relational Routines
StringHandling Routines
Storing a string in alphabetical order
Checking whether a string is alphabetical
Replacing an element in a string
Checking the position of a specific character or substring, within a string
Calculating the length of a string
Deleting blank characters
TalendDataGenerator Routines
Generating fictitious data
TalendDate Routines
Formatting a Date
Checking a Date
Comparing Dates
Configuring a Date
Parsing a Date
Retrieving part of a Date
Formatting the Current Date
TalendString Routines
Formatting an XML string
Trimming a string
Removing accents from a string
TalendStringUtil Routines
Appendices
Customizing Talend Studio and setting Studio preferences
Customizing project settings
Setting the compiler compliance level
Customizing shell command templates
Customizing Maven build script templates
Resynchronizing POM to avoid duplicate projects module definition in the POM for Talend CI builder
Customizing the global build script templates
Customizing the folder-level build script templates
Customizing build script templates for use with CommandLine
Managing deployment versions of Jobs, Routes and Services
Palette Settings
Type mapping
Accessing mapping files and defining type mappings
Supported Talend types
Frequently used attributes in dbType element
Version management
Status management
Job Settings
Configuring component and component update sharing
Stats & Logs
Context settings
Applying Project Settings
Configuring Log4j
Status settings
Security settings
Custom component
Customizing the workspace
Changing the Palette layout and settings
Showing, hiding the Palette and changing its position
Displaying/hiding components families
Maintaining a component family open
Filtering the Palette
Setting the Palette favorite
Changing components layout in the Palette
Changing panels positions
Displaying Job configuration tabs/views
Filtering entries listed in the Repository tree view
Filtering by Job name
Filtering by user
Filtering by Job status
Choosing what repository nodes to display
Setting Talend Studio preferences
Java Interpreter path (Talend)
Designer preferences (Talend > Appearance)
Artifact repository connection preferences (Talend > Artifact Repository)
Artifact repository preferences (Talend > Artifact Repository > Repository Settings)
Update server preferences (Talend > Artifact Repository > Libraries)
Bonita BPM Portal preferences (Talend > Bonita BPM Portal)
How to define the user component folder (Talend > Components)
How to change specific component settings (Talend > Components)
Documentation preferences (Talend > Documentation)
REST Service preferences (Talend > ESB)
Exchange preferences (Talend > Exchange)
Metadata Bridge preferences (Talend > Import/Export)
Language preferences (Talend > Internationalization)
Palette preferences (Talend> Palette Settings)
Performance preferences (Talend > Performance)
Project reference preferences (Talend > Repository)
Debug and Job execution preferences (Talend > Run/Debug)
Displaying special characters for schema columns (Talend > Specific settings)
Schema preferences (Talend > Specific Settings)
SQL Builder preferences (Talend > Specific Settings)
SSL settings preferences (Talend> SSL)
Usage Data Collector preferences (Talend > Usage Data Collector)
Using SQL templates
What is ELT
Introducing Talend SQL templates
Managing Talend SQL templates
Types of system SQL templates
Accessing a system SQL template
Creating user-defined SQL templates
A use case of system SQL templates
Configuring a connection to a MySQL database
Grouping data, writing aggregated data and dropping the source table
Reading the target database and listing the Job execution result
SQL template writing rules
SQL statements
Comment lines
The <%...%> syntax
The <%=...%> syntax
The "</.../>" syntax
Code to access the component schema elements
Code to access the component matrix properties
Talend Studio shortcuts
Keyboard shortcuts available in Talend Studio
Drag and drop shortcuts available in Talend Studio

Back to home page