Flogo
Project Flogo is an open source ecosystem of opinionated event-driven capabilities to simplify building efficient & modern serverless functions, microservices & edge apps.
Install / Use
/learn @TIBCOSoftware/FlogoREADME
Project Flogo is an ultra-light, Go-based open source ecosystem for building event-driven apps. Event-driven, you say? Yup, the notion of triggers and actions are leveraged to process incoming events. An action, a common interface, exposes key capabilities such as application integration, stream processing, etc. <br/>
<p align="center"> <img src ="images/eventhandlers.png" /> </p> <br/>- App = Trigger(s) + Actions[&Activities]
- Triggers
- receive data from external sources.
- are managed by a configurable threading model
- have a common interface enabling anyone to build a Flogo trigger.
- Handlers
- dispatch events to actions
- Actions
- process events in a manner suitable with the implementation
- have a common interface enabling opinionated event processing capabilities
Project Flogo Ecosystem
All capabilities within the Flogo Ecosystem have a few things in common, they all process events (in a manner suitable for the specific purpose) and they all implement the action interface exposed by Flogo Core.
Some of the key highlights include:
🎈 Ultra-light 20x-50x lighter than Java or Node.js <br/> ⚡️ Event-driven Powerful event-driven programming model based on triggers and actions<br/> ⚙️ Common core a single, common core enables reuse and flexibility across all eventing constructs<br/> ✏️ Golang based Written entirely in Golang for efficiency<br/> 💪 Deployment flexibility Deploy as ultra-lightweight serverless functions, containers or static binaries on IoT edge devices<br/> 🧠 Native machine learning Purpose built activity for TensorFlow SavedModel inferencing<br/> 😍 100% Open Source for your dev & hacking pleasure<br/>
<p align="center"> <img src ="images/flogostack.png" /> </p>- Integration Flows Application Integration process engine with conditional branching and a visual development environment<br/>
- Stream Processing a simple pipeline-based stream processing action with event joining capabilities across multiple triggers & aggregation over time windows<br/>
- Contextual Decisioning Declarative Rules for Real-time Contextual Decisions<br/>
- Microgateway Microgateway pattern for conditional, content-based routing, JWT validation, rate limiting, circuit breaking and other common patterns<br/>
The concept is simple, an event is just that, an event, how it’s processed is what differs. Flogo Core eases the burden by enabling a common set of functionality, such as:
- threading
- logging
- data type coercion
- data mapping
- tracing & monitoring hooks
While also exposing a common set of contributions via activities and triggers. For example, all available triggers can be leveraged to dispatch events to any action implementation, that is, flows for application integration, streams for stream processing, rules for contextual rule processing, etc.
Flogo Repos
Project Flogo consists of the following sub-projects available as separate repos under a seperated GitHub Org:
- project-flogo/flogo-cli: Command line tools for building Flogo apps & extensions
- project-flogo/flogo-core: The core Flogo library
- project-flogo/flogo-contrib: Flogo contributions/extensions
- project-flogo/stream: Flogo Streams Action
- project-flogo/rules: Contextual, deterministic rules action
- project-flogo/microgateway: Flogo Microgateway Action
- project-flogo/flogo-web: Flogo Web UI
Flogo Core
Flogo Core is an event-driven app framework used to develop apps for the cloud & IoT edge. It can also be thought of as a lightweight app kernel used by open source & commercial solutions.
Flogo Core provides the following key benefits:
⛓ Action chaining enables communication between one or more capabilities in a single, sub 10MB binary!<br/> 🏗 Common contribution model build activities and triggers that can be leveraged by all capabilities<br/> 🔨 Extensible easily extend the capabilities available by building your own action using the common interfaces<br/>
Flogo Core Contribution Model
Flogo Core exposes three principal contribution interfaces that enable developers to build common capabilities and functionality. These contribution interfaces include:
- Trigger Interface a common interface for building event-consumers that dispatch events to one or more actions. The Kafka subscriber is an example of a trigger.
- Activity Interface a common interface for exposing common application logic in a reusable manner. Think of this as a function, such as write to database, publish to Kafka, etc that can be used by all Flogo apps.
- Action Interface a common interface for processing events. Actions contain the specific capability logic, such as integration, stream processing, rule processing, etc. Actions have a great deal of flexibility in how they’re developed and how developers leverage actions within their overall applications. For example, flows and streams expose JSON-based DSLs & Go APIs for maximum developer flexibility.
Flogo Flows
Flogo Flows provides application integration capabilities and includes the following key highlights.
🌈 Painless development Visual modeler with step-back debugging capabilities & elegant DSL<br/> ⚙️ Ultra-light process engine for conditional flow control
Getting Started
We've made getting started with Flogo Flows as easy as possible. The current set of tooling is designed for:
- Serverless function developers
- Cloud-native microservices developers
- IoT Solutions developers
- <a href="#golang-api">Go Developers</a>
Zero-code Developers
If your background is in or you prefer to develop your apps using zero-coding environments, then read on, because we’ve got something special for you.
Flows Web UI is available via Docker Hub or Flogo.io. The Docker image contains the Flows Web UI along with all required components to begin developing, testing and building deployable artifacts right from your web browser.
To report any issues with the Issue tracker on this project.
Flogo Streams
Edge devices have the potential for producing millions or even billions of events at rapid intervals, often times the events on their own are meaningless, hence the need to provide basic streaming operations against the slew of events.
A native streaming action as part of the Project Flogo Ecosystem accomplishes the following primary objectives:
- Enables apps to implement basic streaming constructs in a simple pipeline fashion
- Provides non-persistent state for streaming operations
- Streams are persisted in memory until the end of the pipeline
- Serves as a pre-process pipeline for raw data to perform basic mathematical and logical operations. Ideal for feeding ML models
Some of the key highlights include:
😀 Simple pipeline construct enables a clean, easy way of dealing with streams of data<br/> ⏳ Stream aggregation across streams using time or event tumbling & sliding windows<br/> 🙌 Join streams from multiple event sources<br/> 🌪 Filter out the noise with stream filtering capabilities<br/>
Getting Started
We’ve made building powerful streaming pipelines as easy as possible. Develop your pipelines using:
- A simple, clean JSON-based DSL
- Golang API
See the sample below of an aggregation pipeline (for brevity, the triggers and metadata of the resource has been omitted). Also don’t forget to check out the examples in the project-flogo/stream repo.
"stages": [
{
"ref": "github.com/project-flogo/stream/activity/aggregate",
"settings": {
"function": "sum",
"windowType": "timeTumbling",
"windowSize": "5000"
},
"input": {
"value": "=$.input"
}
},
{
"ref": "github.com/project-flogo/contrib/activity/log",
"input": {
"message": "=$.result"
}
}
]
Flogo Rules
Processing Events in real-time to determine next best action is an important function of Event driven applications. With the vast amount of events that are generated from different sources, making sense of the information in a given context can be immensely valuable.
Flogo Rules simplifies the complexity involved with real-time contextual decisions.
Flogo Rules supports
- Declarative Rules to define conditional logic and trigger result rules
- Joins/Correlations across multiple Event sources
- Ability to define Rule Priorities
- Timer Events; Configurable TTL (time to live) -1 - no expiry, 0
