Design Paths

This page shows where to start when you create an integration microservice, depending on what you are building.

Overview

Depending on the integration requirements, an engineer can choose from three distinct starting points. Whether you are building traditional data pipelines, designing strict REST contracts, or architecting event-driven systems, Talisman provides a tailored path that converges on a unified runtime experience.

graph TD
    subgraph S1 [Data Pipeline]
        direction TB
        P1(Create Project)
    end

    subgraph S2 [REST API]
        direction TB
        P2(Create Project) --> OA(Design OpenAPI)
        OA --> GR2(Generate Routes)
    end

    subgraph S3 [Event-Driven]
        direction TB
        AA(Design Shared AsyncAPI) --> GP3(Generate Projects)
        GP3 --> GR3(Generate Routes)
    end

    %% Convergence
    R1(Implement Routes)
    GR2 --> R1
    GR3 --> R1
    P1 --> R1
    R1 --> DevMode

    %% Common Steps
    DevMode(Run in Developer Mode) --> Build(Build & Deploy)
    Build --> Monitor(Monitor in Dashboard)

    %% Styling
    style DevMode fill:#e978261a,stroke:#E97826
    style Build fill:#e978261a,stroke:#E97826
    style Monitor fill:#e978261a,stroke:#E97826
    style R1 fill:#e978261a,stroke:#E97826

Traditional Data Pipelines

Best for: Database migrations, file transfers, scheduled jobs, and internal system orchestration.

On this path, the developer works directly with Apache Camel constructs to move and transform data.

Create Project: Initialize a generic integration workspace.
Implement Routes: Use the Route Designer to define logic (e.g., from(timer).to(db)).
Configure Beans: Define connections for Databases, JMS brokers, or specialized components.
Run & Deploy: Enter the common developer loop.

REST API First

Best for: Exposing synchronous microservices to web or mobile clients.

On this path, the contract defines the implementation. The developer focuses on the API structure before writing logic.

Create Project: Initialize a generic integration workspace.
Design OpenAPI Contract: Use the OpenAPI Designer to define Paths, Data Types, and Responses specific to this project.
Generate Routes: Talisman generates the Apache Camel Route with direct:{{operationId}} for each Operation
Implement Logic: Connect the generated API operations to business logic routes.
Run & Deploy: Enter the common developer loop.

Event-Driven Architecture

Best for: Asynchronous messaging, pub/sub systems, and inter-service communication.

On this path, the architecture is defined globally using a shared contract.

Design Shared AsyncAPI: Use the AsyncAPI Designer to model the topology, defining Servers, Channels, and Messages for the entire platform.
Generate Projects & Routes: The designer scaffolds the specific microservices (Projects) and generates the send/receive routes automatically.
Implement Logic: Add business logic between the pre-wired inputs and outputs.
Run & Deploy: Enter the common developer loop.

Common Runtime Steps

Whichever path you start from, the project then goes through the same run, build and deploy steps.

Run in Developer Mode

To facilitate rapid iteration, Talisman runs your integration in a dedicated container with hot reload capabilities.

Trace: Examine message exchanges in real-time.
Debug: Inspect headers and body payloads as they flow through routes.

Follow the Developer Mode guide. You can run this locally using Studio for VS Code or remotely on the dev Talisman Server.

Build and Deploy

Once the logic is verified, the project is built into a container image and deployed. Where that happens depends on your deployment option: the dev Talisman Server builds it (Server Build), or your CI does (CI/CD Build).

Monitor with Dashboard

After deployment, the Talisman Dashboard provides observability out of the box.

Metrics: View throughput, failure rates, and latency.
Topology: Visualize how your service connects to the rest of the ecosystem.

More information about Observability.