Layotto Documentation

Layotto is an application runtime developed in Golang designed to help developers build cloud-native applications by decoupling them from the underlying infrastructure. It provides distributed capabilities such as state management, configuration management, and event pub/sub.

Built on top of the open-source MOSN, Layotto combines Multi-Runtime capabilities with Service Mesh features. It can act as a data plane for Istio while simultaneously providing Runtime APIs (e.g., Configuration, Pub/Sub) without requiring additional sidecars. It also supports using WebAssembly (WASM) to function as a FaaS (Function as a Service) runtime container.

Layotto provides a set of APIs designed to allow application developers to leverage distributed capabilities directly within their code. Instead of managing complex distributed systems logic manually, developers can call Layotto APIs to access services such as:

• Distributed Databases: Accessing managed data stores.
• Distributed Locks: Managing concurrency across multiple instances.
• Other Distributed Capabilities: Various other primitives provided by the Layotto runtime.

Programming against the Layotto API allows you to offload the complexity of distributed systems to the Layotto layer.

The Layotto Actuator API provides HTTP endpoints for health checks and retrieving runtime metadata. It is designed for integration with operational infrastructure like Kubernetes (e.g., for liveness and readiness probes) or SRE dashboards to monitor the status of Layotto and the application.

By default, these APIs return metadata for Layotto. To include application-specific metadata or health status, you must develop a plugin that calls back to the application. The API follows a RESTful pattern: /actuator/{endpoint_name}/{params}.

Layotto is evolving its feature set. The current and planned capabilities include:

• Currently Supported: RPC, Config, Pub/Sub, and Actuator.
• Planned (Short-term): Distributed Lock, State, and Observability.
• Future Goals: Plugin architecture to allow Layotto to run on Envoy and further expansion of WebAssembly integration.

Layotto's runtime capabilities are exposed via gRPC APIs defined in proto files. These APIs are categorized into two main types:

1. Runtime APIs:

   • App-facing APIs: APIs that Layotto provides to your application to facilitate orchestration and service mesh features.
   • Callback APIs: APIs that your application must implement so that Layotto can call back into your app (e.g., to retrieve pubsub subscription messages).

2. Extension APIs: Specialized APIs for specific functionalities such as storage, communication, and messaging.

Detailed documentation for the runtime and extension interfaces can be found at the official Layotto API portal.

<!-- Detailed API documentation is available at: -->
https://mosn.io/layotto/api/v1/runtime.html

The Sequencer API is used to generate distributed, unique, and auto-incrementing IDs. It supports two types of incrementing requirements:

• WEAK: Trend-increasing IDs.
• STRONG: Strictly increasing IDs.

The SmsService is a Layotto API used to send SMS messages.

Developers can interact with this service in two ways:

1. Using SDKs: Layotto provides multi-language SDKs (e.g., Go SDK located in the sdk directory, and a Java SDK available at https://github.com/layotto/java-sdk).
2. Direct gRPC: You can use any programming language to interact with Layotto directly via gRPC.

The State API is a set of Key/Value CRUD (Create, Read, Update, Delete) operations that allows your application to interact with different databases or storage systems using a unified interface.

By using the State API, you can:

• Decouple from Cloud/Storage Providers: Deploy the same business logic across different environments without changing code.
• Reuse Middleware Across Languages: Instead of maintaining language-specific SDKs (e.g., for Java and Python), different applications can interact with the same database and middleware using a single set of gRPC APIs via Layotto.