Skip to content

Initializing search

Installation & Configuration
Developing
CI/CD
Appendicies

Martini

Installation & Configuration
Installation & Configuration
- Account Setup
  Account Setup
- Designer Desktop Edition
  Designer Desktop Edition
- 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
- 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
- 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
- Webpage Templates
  Webpage Templates
CI/CD
CI/CD
- Continuous Integration
  Continuous Integration
- Continous Deployment
  Continous Deployment
- Manual Deployment
  Manual Deployment
  - Martini Manually Deploying Projects
Appendicies
Appendicies
- Designer User Interface
  Designer User Interface
- Version Release Notes
- Migration Guide
- Library Dependencies
- Benchmarking
- Javadoc

Martini Microservices Protocols & Methods

Page Placeholder

This page is to be updated before publishing.

Developing Microservices

"Lonti" is a trademark of Lonti.com Pty Ltd ACN 643 086 024. ©Lonti.com Pty Ltd. All rights reserved.