Initializing search
Latest
v1.x
Martini Docs
Bellini Docs
Negroni Docs
_________
Community Q&A
Knowledge Base
Support
Installation & Configuration
CI/CD
Developing
Appendicies
Martini
Installation & Configuration
Installation & Configuration
Designer Desktop
Designer Desktop
System Requirements
Installation
Configuration
Installing Updates
Designer Online
Designer Online
Lonti Managed Hosting
Lonti Managed Hosting
Setup
Configuration
Installing Updates
Self-managed
Self-managed
System Requirements
Installation
Installation
AWS
Azure
GitHub Codespaces
Google Cloud
On-Premise
Configuration
Installing Updates
Server Runtime
Server Runtime
Lonti Managed Hosting
Lonti Managed Hosting
Setup
Configuration
Installing Updates
Self-managed
Self-managed
Installation
Installation
System Requirements
License Management
Best Practices
AWS
Azure
Consul
Google Cloud
Kubernetes
On-Premise
Configuration
Configuration
Server Management
Server Management
Local file system
Remote Management
Remote Management
Martini REST API
CLI Tool
Environments
Environments
Managing Environments
Configuring Environments
Properties
Properties
Types and Heirarchy
Package Properties
Application Properties
System Properties
Environmental Variables
Dependencies
Dependencies
Databases
Databases
Configuring Databases
Configuring JDBC
Cassandra
DynamoDB
MongoDB
MySQL
Oracle
PostgreSQL
Presto
Redis
Redshift
Snowflake
SQL Server
Synapse
Message Brokers
Message Brokers
ActiveMQ Artemis
ActiveMQ Classic
AWS SQS
Kafka
RabbitMQ
Solr
Log Files
Log Files
Application Logs
Log Levels
Fish Tagging
Rotation & Retention
Performance Tuning
Performance Tuning
JVM Tuning
Tomcat Configuration
Security
Security
Security Considerations
Authentication/Authorization
SSL/TLS Configuration
SSL/TLS Configuration
SSL Termination
Configuring SSL
Configuring SSL
Public CA
Let's Encrypt
Self-signed
Configuring APR
Configuring HSTS
Encryption at Rest
Configuring Vault
Monitoring
Monitoring
Server Admin UI
Server Admin UI
Monitoring Endpoints
Monitoring Logs
Threads
User Sessions
HTTP requests
Broker destinations
Service Manager
JDBC Connections
Metrics API
Monitoring Endpoint
CI/CD
CI/CD
Configuring Git
Configuring Git
Setting up Git
Manual Deployment
Automated Deployment
Automated Deployment
AWS CodePipeline
Azure Pipelines
Bitbucket Pipelines
Github Actions
Gitlab Pipelines
Validation & Testing
Validation & Testing
Validation
Testing
Developing
Developing
Getting Started
Getting Started
User Interface
User Interface
Main Navigation
Main Navigation
Overview
Navigator
Marketplace
Editors
Editors
Workflow Editor
API Editor
Service Editor
Database Service Editor
Data Model Editor
Webpage Editor
Groovy Editor
Tools
Tools
HTTP Client
Source Control
Debugger
Users & Groups
Views
Views
Database View
Console
Tracker
Project Packages
Project Packages
Creating/Deleting
Import/Export
Package States
Package Properties
Secrets Management
Dependency Management
Package Metadata
Core Package
Spring Context
Workspaces
Workspaces
Designer Desktop
Designer Online
Video Tutorials
Video Tutorials
Services
Services
Introduction
Workflows
Workflows
Concepts & Usage
Concepts & Usage
Key Concepts
Synchronous vs Asynchronous
Workflows vs Services
Creating & Editing
Creating & Editing
Creating/Deleting
Import/Export
Workflow Designer
Inputs & Outputs
Workflow Nodes
Workflow Nodes
API Invocation Node
Trigger Node
Webhook Node
Map Node
Invoke Service Node
Invoke Function Node
Invoke Workflow Node
Script Node
Random Node
Try Catch Node
Repeat Node
Fork Node
Database Node
Wait Event Node
Wait Time Node
Dependencies & Versioning
Dependencies & Versioning
Managing Versioning
Managing Dependencies
Monitoring & Logging
Monitoring & Logging
Logging
Monitoring
Error Handling & Debugging
Error Handling & Debugging
Workflow Errors
Console Errors
Error Handling
Debugging Workflows
Workflow Logs
Documenting Workflows
Documenting Workflows
Workflow Documentation
Documenting a Node
Services
Services
Concepts & Usage
Concepts & Usage
Key Concepts
Reusability
Creating Services
Creating Services
Creating/Deleting
Import/Export
Service Editor
Inputs & Outputs
Invoking Services
Invoking Services
Invoking via UI
Invoking via HTTP
Invoking via Trigger
Invoking via Trigger
AWS SQS
Directory Watcher
Email
FTP
GraphQL Database Reader
HTTP Filter
Jabber
JMS
Kafka
RSS
Scheduler
Tracker Resubmit
URL Alias
MongoDB Change Stream
Redis Pub/Sub
Service Step Operations
Service Step Operations
Map Step
Fork Step
Block Step
Iterate Step
While Step
Break Step
Script Step
Concurrent Step
Random Step
Functions
Functions
BigTable Functions
Boolean Functions
Cache Functions
CSV Functions
Custom Functions
Database Connection Pool Functions
Email Functions
Flat File Functions
Workflow Functions
Service Functions
Groovy Functions
HTTP Functions
JMS Functions
JSON Functions
Logger Functions
Marshaller Functions
Martini Runtime Functions
Number Functions
Proxy Request Functions
Remote Deployment Functions
REST Functions
RSS Functions
Service Registry Functions
Stream Functions
String Functions
SQL Functions
Tracker Functions
URL Functions
User Group Functions
Util Functions
Velocity Functions
VFS Functions
Vault Functions
XML Functions
Groovy Methods
Groovy Methods
Creating
Inputs & Outputs
Groovy Editor
Running
Invoking
Groovydoc
Annotations
Compilation
HTTP Endpoint
JAR Files
JAR Files
Importing JAR Files
Using JARs in Services
Compatibility & Versioning
Dependencies & Versioning
Dependencies & Versioning
Service Versioning
Service Dependencies
Monitoring & Logging
Monitoring & Logging
Logging to Console
Tracker Transaction Log
Tracker Transaction Log
Tracker Databases
Enabling Tracker
Document Structure
Logging Data
Tracker Search API
Resubmitting Transactions
Indexing Tracker Data
Performance Analysis
Metrics API
Security Considerations
Security Considerations
Authentication & Authorization
Data Encryption & Masking
Storing Secrets
Error Handling & Debugging
Error Handling & Debugging
Error Handling
Service Errors
Console Errors
Debugging Services
Creating Breakpoints
Analyzing Service Logs
Documenting a Service
Creating APIs
Creating APIs
Creating REST APIs
Creating REST APIs
Creating & Importing
Setting Paths
Setting HTTP Methods
Adding Parameters & Headers
Response Handling & Mocking
Configuring Endpoints
Error Handling
Validation & Testing
Creating GraphQL APIs
Creating GraphQL APIs
GraphQL Database Reader
Creating GraphQL Schemas
Defining Queries & Mutations
Resolvers & Subscriptions
Validation & Testing
Using the HTTP Client
Using the HTTP Client
Invoking Martini APIs
Creating Requests
Configuring Requests
Sending Requests
Grouping Requests
Sharing Requests
Cookie Manager
Making API Discoverable
Making API Discoverable
API Documentation
API Explorer
OpenAPI Schema
Postman Collection
Publishing APIs
API Integration
API Integration
Designing API Flows
Design Principles
Consuming APIs
Consuming APIs
Consuming REST APIs
Consuming REST APIs
Configuration & Authentication
Service Generation
Consuming GraphQL APIs
Consuming GraphQL APIs
Configuration & Authentication
Service Generation
Consuming Webhooks
Consuming Webhooks
Configuration & Authentication
Service Generation
Consuming SOAP Services
Consuming SOAP Services
Configuration & Authentication
Service Generation
Consuming AsyncAPI
Consuming AsyncAPI
Configuration & Authentication
Service Generation
Data Mapping/Transformation
Error Handling
Security Considerations
Testing
Logging
Monitoring
Application Integration
Application Integration
Integration Patterns
Design Principles
Connecting Applications
Creating Workflows
Data Mapping/Transformation
Error Handling
Security Considerations
Testing
Logging
Monitoring
Data Integration
Data Integration
Data Sources
Data Sources
SQL Databases
SQL Databases
SQL Database Connection
SQL Service Editor
SQL Stored Procedures
SQL Views
NoSQL Databases
NoSQL Databases
NoSQL Database Connection
MongoDB Service Editor
Cassandra Service Editor
DynamoDB
Redis
Data Warehouses
Data Warehouses
Data Warehouse Connection
Snowflake
Redshift
BigQuery
Data Lakehouse
Data Lakehouse
Data Lakehouse Connection
PrestoDB
Data Files
Data Files
Flat Files Types
Flat File Editor
Structured Files
Search Indexes
Search Indexes
Solr Search Index
Solr Search Index
Creating a Core
Indexing Documents
Updating Documents
Deleting Documents
Searching Documents
Search API
Data Models
Data Models
Normalizing Data Models
Creating/Deleting
Import/Export
Data Model Editor
Object Types
Object Converters
Model References
Cursors
ETL Processes
ETL Processes
Extracting Data
Data Mapping/Transformation
Data Validation
Loading Data
ELT Processes
ELT Processes
Extracting Data
Loading Data
Event Processing
Event Processing
JMS Messaging
Monitoring & Logging
Security Considerations
Error Handling & Debugging
Stream Processing
Stream Processing
Concepts & Usage
Concepts & Usage
Key Concepts
Intro to Apache Beam
Apache Beam Integration
Creating
Creating
Creating/Deleting
Stream Processing Logic
Data Validation & Transformation
Third-Party Libraries
Third-Party Libraries
Jars
Groovy
Deploying
Deploying
Selecting a Runner
Deploying to Beam
Monitoring & Managing
Data Security & Compliance
Data Security & Compliance
Access Controls & Permissions
Data Encryption & Masking
Auditing & Monitoring
Application Microservices
Application Microservices
Microservcies Overview
Developing Microservices
Protocols & Methods
Data Exchange
Monitoring & Logging
Security Considerations
Error Handling & Debugging
Webpage Templates
Webpage Templates
Webpage Templates Overview
Web Applications
Creating
Importing
Webpage Template Editor
Step Operations
Injecting Templates
Defining Resources
Configuring Routes
Running
Debugging
Appendicies
Appendicies
Designer User Interface
Designer User Interface
None
API Designer
Workflow Designer
Service Editor
SQL Service Editor
MongoDB Service Editor
Cassandra Service Editor
Flat File Service Editor
Webpage Template Editor
Debugger
Version Release Notes
Migration Guide
Library Dependencies
Benchmarking
Javadoc
API Editor
Back to top