Kumologica: First low-code development tool for AWS Lambda

By now, you may have noticed the trend in IT to reduce the size of existing things (projects, teams, releases, hardware, services). It seems like yesterday when we were talking about the need to break the monolith into microservices and we are already talking about encapsulating your logic into functions.

Given the simplicity and economic appeal of FaaS (Function as a Service) offerings, it seems like a natural move to see the world of integration begin to shift toward a new serverless model and start to enjoy its benefits like autoscaling, no infrastructure management and pay-per-use billing.

Kumologica is one of the early players in this space, with a very clear mission: bring the benefits of the traditional low-code integration platforms to the new world of FaaS.

“the whole history of computer science is one of ever rising levels of abstraction” — Grady Booch

Introducing Kumologica

Kumologica consists of two parts:

• Kumologica designer: A low-code environment where developers can create API Integration flows by arranging and connecting visually (drag-and-drop) a number of pre-packaged nodes. It also allows developers to test and deploy API integration flows into the cloud directly without having to go to the terminal or cloud console for anything.
• Kumologica runtime: A library which is responsible to run integration flows on top of your FaaS in a scalable, high performing and cost-efficient manner.

Kumologica Designer In Action

Benefits

In addition to all the benefits aforementioned of using FaaS, there are two main benefits you will enjoy when choosing Kumologica:

• Cloud portability: You have one tool and one way to describe and run your integration flows, and thanks to the different cloud bindings, there is no headache anymore in porting those flows to other cloud providers. Reducing the risk of cloud vendor lock-in.
• Quick development feedback-loop: Develop with zero or almost zero code, test your flows locally (without any Docker dependencies) and deploy into the cloud in a secure and quick manner, and all within your designer. No need to jump into the terminal to run other scripts, or go to web consoles to configure security roles / triggers etc. Kumologica Designer will take care of these tasks for you.

We consider Kumologica to be the one of the best ways to develop, test and deploy integration services in the new serverless world. To prove it, we will demonstrate the capabilities of Kumologica by implementing a number of different use cases in a series of articles.

In today’s first article, we will develop a simple HTTP based API with a DynamoDB backend.

Use Case: Contact Form API

It’s very common to see API’s for most of the websites contact page in order to interact with a backend storage. In this article, we’re going to build a Contact API service flow that will persist the contact details (name, email, company and message) into a DynamoDB table.

Prerequisites

Before we get started, please make sure the following prerequisites are met:

1. NPM Installed
2. AWS profile configured in your machine
3. Kumologica Designer studio (free download here)
4. Postman, curl or any other rest api testing client (Optional)

If you need help, please visit our installation guide here.

DynamoDB Setup

For this tutorial we need to create an AWS dynamoDB contacts table with the following columns:

• name (Primary Key)
• email_id
• message
• company

Your table must look like this:

Contacts API Flow

This API involved validating the posted request and then inserting the records to dynamoDB.

1. Open Kumologica Designer.
2. On the popup Click Create New Project.
3. Provide the Project Name and Location to save your project and click Save.

You will be presented with an example hello-world flow, like the one below. Select the three nodes and delete them.

Now we are ready to build our new flow…

4. Find the EventListener node from the palette under the AWS category and drag it onto the canvas.

5. Double click the EventListener node to open the configuration editor and set the following values, and click Save.

Display Name: (Left it blank)
EventSource: Amazon API Gateway
Verb: POST
URL: /contact

6. Find the JSON Validator node from the palette under the validation section and drag it onto the canvas.

7. Double click the JSON Validator node to open the configuration editor and set the following values, and click Save.

Display Name: Validation
JSON Schema Area:
{
 "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
     "name": {
        "type": "string"
     },
     "email_id": {
        "type": "string"
     },
     "message": {
        "type": "string"
     },
     "company": {
        "type": "string"
     }
  },
  "required": [ "name", "email_id" ]
}

8. Find the DynamoDB node from the palette under the AWS section and drag it onto the canvas.

9. Provide the configuration for DynamoDB as given below and click Save.

10. Find the EventListener End node from the palette under the AWS section and drag it onto the canvas.

11. Double click the EventListener End node and configure as given below and click Save.

And that’s it! — The resulting flow must be looking like this:

Now, come the fun part. Let’s finish it by deploying the flow as a lambda and test it.

Deployment

1. On the right hand side of the Designer. Click on the AWS icon and select the AWS profile from the drop down that you have configured in your machine.
2. Set the memory to 512Mb
3. Set the timeout to 20 seconds (default is 5 seconds).
4. Under triggers section, set the following configuration:

API: Create new API 
Deployment Stage: dev
Security Type: NONE

4. On the top right hand side corner of your designer select the icon representing bottom panel to open the terminal.

5. Finally, click the Deploy button on the top.

At this point, Kumologica will create a role that will give lambda access to the resources (DynamoDB); it will also build a new API Gateway and it will attach it as a trigger to the flow.

You can see the output of all these operations from the terminal window. Please have a look at the end of the deployment logs for the assigned API Gateway endpoint for your flow.

Test

After deployment is completed, you can curl your /contact endpoint with:

curl --request POST  \
     --url <api_gateway_endpoint> \
     --header "Content-Type: application/json"   \
     --data '{
       “name”: “Harry”,
       “email_id”: “harry@xyz.com”,
       “message” : “would like to know more about Kumologica.”,
       “company”: “xyz.inc” }'

Conclusion

Developing and deploying API integrations with Kumologica is simple and straightforward, involving very little or no code as demonstrated in this article.

Remember Kumologica is totally free to download and use. Go ahead and give it a try, we would love to hear your feedback.

In the meantime, if there is any specific use case that you would like to see in a future article please let us know in the comments section.

Closing Note

Thanks for reading. I hope you like this article. Feel free to like, comment or share this article with your friends. For more depth understanding of Kumologica solution checkout our official documentation at kumologica.com