This blog post takes you on a guided tour of building event-driven serverless applications using TIBCO Flogo, focusing on the development process from start to finish. We'll delve into creating connections, designing flows, and configuring activities to demonstrate the end-to-end execution path of a real-world use case.


In this tutorial, you will gain a comprehensive understanding of how to leverage TIBCO Flogo to develop powerful serverless applications. 

By the end of this post, you'll be equipped with the knowledge and skills to build your own serverless solutions using Flogo.

Before we begin, make sure you have the following:

Automating a Business Process (Eco Label API)

Imagine a scenario where you need to automate a business process that involves interacting with external APIs, retrieving data, processing information, and storing results. This could be anything from processing orders and updating inventory to validating data and generating reports.

For this demonstration, we are preparing eco label service:&nbsp; a service that seamlessly handles the intricate dance of requesting and managing eco-labels for your products. A service that effortlessly navigates the complexities of external APIs, gathers crucial product information, deciphers responses, and stores data with unwavering precision.

This is where the magic of TIBCO Flogo comes alive.  Its lightweight and flexible framework empowers you to build event-driven serverless functions that bring this vision to life.  Flogo orchestrates the entire process, ensuring your products are adorned with the badges of environmental responsibility, effortlessly and efficiently.

Before we begin with application lets understand designing methodology of the TIBCO Flogo application.

This flowchart provides a clear and concise roadmap for creating a Flogo application. It outlines the essential steps involved, from setting up the initial app structure to validating and deploying the final product. The inclusion of data mapping highlights Flogo's ability to seamlessly connect different components and ensure smooth data flow throughout the application. 

This visual guide serves as a valuable tool for both novice and experienced Flogo developers, streamlining the development process and fostering efficient application creation.

Overview

&nbsp;The Building Blocks of Event-Driven Applications

TIBCO Flogo stands out as a powerful open-source framework for building event-driven applications, especially in the serverless realm. But what exactly constitutes a Flogo app? Let's dissect its anatomy and explore the key components that bring these applications to life.

Every Flogo application begins with a trigger. Triggers act as the entry points, listening for specific events or requests that initiate the application's execution. Flogo offers a variety of triggers, including:

Activities are the building blocks of Flogo apps, performing specific actions within a flow. Flogo provides a rich library of pre-built activities for common tasks, such as:

Flows define the execution logic of your Flogo application. They connect triggers and activities, determining the sequence of actions performed in response to a trigger event. Flows can be simple linear sequences or complex branching structures with conditional logic and loops.

Connections establish links between your Flogo app and external systems or services. They provide the necessary configuration for Flogo to interact with these external entities, such as:

5. Application Properties: The Global Context

Application properties act as global variables within your Flogo app. They store configuration parameters, constants, or shared data that can be accessed by any activity in the flow. This provides a centralized way to manage application-wide settings. More details are in the next section.

Flogo uses JSON Schema to define the structure of data flowing through your application. This helps validate data, ensure consistency, and auto-generate forms for configuring activities.&nbsp;More details are in the next section.

Flogo's built-in flow tester allows you to debug and test your flows locally. You can simulate trigger events, step through activities, set breakpoints, and inspect variables to ensure your application works as expected.&nbsp;More details are in the next section.

Once your Flogo application is developed and tested, you can deploy it in various ways:

By understanding these core components, you can effectively leverage TIBCO Flogo to build robust, event-driven applications that meet the demands of modern architectures.

Anatomy of a Flogo App

Now, let's dive into the heart of our application: the Flogo flow. While this blog post won't cover the actual deployment, configuring this trigger requires establishing an AWS connection within your Flogo development environment. 

The application has the following steps involved in this automated process:

Before we dive into the Flogo application, let's establish a connection to our AWS environment. Flogo offers a dedicated "ReceiveLambdaInvocation" trigger, indicating its readiness for serverless deployments.

Flogo's visual development environment goes beyond just designing the flow of your application. It also provides a powerful drag-and-drop interface for mapping data between different activities. This feature allows you to easily:

Transform data: Convert data from one format to another (e.g., extract fields from a JSON object, convert strings to numbers).

Map fields: Map data from the output of one activity to the input of another activity.

Create expressions: Build expressions to manipulate and combine data values.

This drag-and-drop mapping capability simplifies the process of working with data in your Flogo applications, making it more intuitive and less error-prone. It's a key feature that enhances Flogo's ease of use and accelerates development.

Each activity in the Flogo flow needs to be configured with the necessary parameters to perform its task. This involves:

In addition to configuring individual activities, Flogo allows you to define application-level properties. These properties act as global variables that can be accessed and used throughout your Flogo application. Application properties are useful for storing:

You can define application properties within your Flogo app's configuration file or through the Flogo web UI. These properties can then be accessed and used in your flow's activities using expressions or data mappings.

The application properties are available for use at various level in application for activity configuration as described in below screen captures:

Flogo uses JSON Schema to define the structure of data flowing through your application. A JSON Schema is a specification that describes the format and constraints of a JSON document. In Flogo, you can use JSON Schema to:

By defining clear and concise JSON Schemas for your Flogo application, you can improve data quality, reduce errors, and enhance the maintainability of your serverless functions.

From Idea to Application

Catch Bugs Early: Local Flow Testing with Flogo

Before deploying your Flogo application, it's essential to ensure that it functions correctly. Flogo provides a built-in flow tester/test case feature through vscode extension that allows you to debug and test your flows locally. With the flow tester, you can:

By thoroughly testing your flows locally, you can identify and resolve issues before deploying to a live environment, ensuring the reliability and stability of your serverless applications.

Let's understand how to perform local testing.

Flow test case and unit tests are essential tools in the Flogo developer's arsenal. They help ensure that your Flogo applications function correctly and reliably before you deploy them.

By creating these comprehensive test cases and unit tests, you can:

Investing time in writing effective flow test cases and unit tests is a crucial step in building high-quality Flogo applications that meet the demands of modern serverless architectures.

Test Drive Your Flows 

TIBCO Flogo offers a compelling approach to building event-driven serverless applications. Its visual development environment, coupled with features like drag-and-drop mapping and built-in testing tools, simplifies the development process and empowers developers to create efficient and robust solutions. 

Flogo's lightweight nature and support for various deployment models make it a versatile choice for modern application development, particularly in the realm of serverless computing. By embracing Flogo, developers can streamline their workflows, accelerate development cycles, and focus on delivering innovative solutions that meet the demands of today's dynamic technological landscape.

While this blog post won't cover the actual deployment and to understand deployment of Flogo to AWS Lambda check out our blog:&nbsp;<a href="https://walkthrough.so/pblc/gKvgsyDhHksN/effortless-tibco-flogo-deployments-on-aws-lambda-with-terraform">Effortless TIBCO Flogo Deployments on AWS Lambda with Terraform</a>

Ready to experience the power of Flogo for yourself?

Building Event-Driven Serverless Applications with TIBCO Flogo: A Development Deep Dive

Milind Pandav

What You Will Learn

Prerequisites

The Use Case

Automating a Business Process (Eco Label API)

Workflow of Flogo App Development

References