Skip to content
Initializing search
Latest
v1.x
Martini Docs
Bellini Docs
Negroni Docs
_________
Community Q&A
Knowledge Base
Support
Installation & Configuration
Developing
CI/CD
Appendicies
Martini
Installation & Configuration
Installation & Configuration
Account Setup
Account Setup
Create an Account
Organization Users
Plan Features
Upgrade a Plan
Downgrade a Plan
Designer Desktop Edition
Designer Desktop Edition
System Requirements
Installation
Configuration
Installing Updates
Troubleshooting
Designer Team Workspace
Designer Team Workspace
Lonti Managed Hosting
Lonti Managed Hosting
None
Plans
Setup
Configuration
Installing Updates
Self-Managed Hosting
Self-Managed Hosting
None
System Requirements
Installation
Installation
AWS
Azure
GitHub Codespaces
Google Cloud
Other Host
Configuration
Installing Updates
Server Runtime
Server Runtime
Lonti Managed Hosting
Lonti Managed Hosting
None
Plans
Setup
Configuration
Installing Updates
Self-Managed Hosting
Self-Managed Hosting
Installation
Installation
System Requirements
License Management
Installing
Initial Configuration
Architecture Options
Architecture Options
API Gateway
AWS ECS
AWS EKS
Azure AKS
Consul
Google GKE
Kubernetes
Load Balancer
Docker Swarm
Configuration
Configuration
Application Properties
Configuration Tools
Environmental Variables
Security
Best Practices
Dependencies
Dependencies
JVM
Tomcat
JDBC
ActiveMQ Classic
ActiveMQ Artemis
RabbitMQ
Solr
Log Files
Log Files
None
Application Logs
Log Levels
Fish Tagging
Rotation & Retention
Monitoring & Alerting
Monitoring & Alerting
None
Monitoring Endpoints
Monitoring Logs
Threads
User Sessions
HTTP requests
Broker destinations
Service Manager
JDBC Connections
Developing
Developing
Project Packages
Project Packages
Creating/Deleting
Import/Export
Package States
Package Properties
Secrets Management
Dependency Management
Directory Structure
Package Metadata
Core Package
Spring Context
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
Message Brokers
Message Brokers
Apache ActiveMQ Classic
Apache ActiveMQ Artemis
RabbitMQ
AWS SQS
Kafka
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
CI/CD
CI/CD
Continuous Integration
Continuous Integration
Continous Deployment
Continous Deployment
AWS CodePipeline
Azure Pipelines
Bitbucket Pipelines
Bamboo
Github Actions
Gitlab Pipelines
Jenkins
Deployment API
Validation & Testing
Manual Deployment
Manual Deployment
Martini Manually Deploying Projects
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
Martini Services Step Operations
Page Placeholder
This page is to be updated before publishing.
Back to top