Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/nchabanoles/microservices-orchestration-talk

Demo support of an integration between Kafka and Bonita with nodejs microservices
https://github.com/nchabanoles/microservices-orchestration-talk

bonita bonitabpm docker java kafka microservices-architecture microservices-demo nodejs

Last synced: about 2 months ago
JSON representation

Demo support of an integration between Kafka and Bonita with nodejs microservices

Host: GitHub
URL: https://github.com/nchabanoles/microservices-orchestration-talk
Owner: nchabanoles
Created: 2019-10-09T13:46:09.000Z (almost 5 years ago)
Default Branch: master
Last Pushed: 2022-12-07T01:00:55.000Z (almost 2 years ago)
Last Synced: 2024-04-30T12:36:54.880Z (5 months ago)
Topics: bonita, bonitabpm, docker, java, kafka, microservices-architecture, microservices-demo, nodejs
Language: Java
Homepage:
Size: 507 KB
Stars: 3
Watchers: 3
Forks: 2
Open Issues: 6
Metadata Files:
- Readme: README.md

Awesome Lists containing this project

README

# Microservices in an Event-Driven Architecture using Bonita and Apache Kafka

This repository contains the material used for my talk about Event-Driven Architecture for Microservices. I demonstrate how Bonita (a BPMs) can be a game changer in such an architecture in term of robusteness, maintanability, evolutivity and monitoring.

## Overview

As examples here are 4 sub-projects implementing an e-commerce application.

* order:
A sample NodeJS implementation of an Order service. This service simulates a user placing a new order to buy some goods.
* payment:
A sample NodeJS implementation of a Payment service. This service simulates a system charging customers credit card.
* shipment:
A sample NodeJS implementation of a Shipment service. This service simulates a robotic system packing goods to be sent via post mail.

There is also a pre-built adapter hiding the Apache Kafka listening logic to communicate with a Bonita application (BPMN process based app). The implementation of the Bonita application can be found in the [microservice-orchestration-bonita-order-process-example](https://github.com/nchabanoles/microservice-orchestration-bonita-order-process-example) GitHub repository. As an alternative the .bos file is also available [here](https://github.com/nchabanoles/microservice-orchestration-bonita-order-process-example/releases/download/v1.0-beta/OrdersManagement-Microservices-1.0.bos).
![Event-Driven Architecture with Bonita](https://github.com/nchabanoles/microservices-orchestration-talk/raw/master/pics/Event-Driven_Microservices_Bonita-e-commerce.png)

## How To Use

### Prerequisites
* [Apache Kafka](https://kafka.apache.org/)
* [Bonita](https://www.bonitasoft.com/) [![Maven Central](https://maven-badges.herokuapp.com/maven-central/org.bonitasoft.engine/bonita-server/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.bonitasoft.engine/bonita-server)
* [NodeJS](https://nodejs.org/en/)
* [Java 8+](http://www.oracle.com/technetwork/java/javase/downloads/index.html)

### Build
```
$ cd bonita-kafka-watcher
$ ./gradlew build
$ cd ../order
$ yarn install
$ cd ../payment
$ yarn install
$ cd ../shipment
$ yarn install
```

### Run

#### bonita-kafka-watcher
**Prerequisites**: Kafka and Bonita servers must be running and accessible. Server URLs can be set in the [application.yml](https://github.com/nchabanoles/microservices-orchestration-talk/raw/master/bonita-kafka-watcher/src/main/resources/application.yml) configuration file.
```
$ cd bonita-kafka-watcher
$ ./gradlew run
```

#### Payment and Shipment services
**Prerequisites**:
* Kafka server is running and reachable
* order service is stopped

From the service folder:
```
$ yarn start
```

#### Order service
**Note**: Each time the order service is started it produces a New Order event and publish it to Kafka. Other services will consume the message (only if they are already running)
```
$ cd order
$ yarn start
```

## Demo

To create a reproducible demo environment you can use the Dockerfile descriptors to build Docker images.
```
$ cd order
$ sudo docker build --no-cache -t nodejs-orders-service:v1 .
$ cd ../payment
$ sudo docker build --no-cache -t nodejs-payments-service:v1 .
$ cd ../shipment
$ sudo docker build --no-cache -t nodejs-shipments-service:v1 .
$ cd ../bonita-kafka-watcher
$ sudo docker build -f Dockerfile-Monitoring --no-cache -t bonita-choreography:v1 .
$ sudo docker build -f Dockerfile-PaymentService --no-cache -t bonita-payments-service-proxy:v1 .
```

**Note**: the bonita-kafka-watcher project is used twice to create 2 distinct docker images. The first one for the Demo 2 and second one for demo 3.

### Demo 1 (no Bonita involved)
**Prerequisites**: Kafka is running and reachable (I started a Docker container locally).

I started a Docker containers locally using [Portainer](https://www.portainer.io/installation/).

* Start Shipment service (nodejs-shipments-service container)
* Start Payment service (nodejs-payments-service container)
* Start Order service (nodejs-orders-service container) ==> an order is automatically issued and processed by Payment service then Shipment service.

Restart the Order service (i.e the Docker container itself) as often as you want to produce a 'New Order Available' event.

### Demo 2 (Bonita as an alternate implementation of Payment service)
For the sake of the completeness of how Bonita can be used in an Event-Driven Microservices Architecture I demonstrated that a microservice can be easily implemented with a BPMN process using Bonita.

**Prerequisites**: Bonita server is running and the Payment service process implementation has been installed. See [microservice-orchestration-bonita-order-process-example](https://github.com/nchabanoles/microservice-orchestration-bonita-order-process-example).

After Demo 1 has been played:
* Stop nodejs-payments-service container
* Start bonita-payments-service-proxy container (it only forwards 'New Order Available' messages to Bonita)
* Open Bonita admin console to the see the process execution
* Re-start nodejs-orders-service container to produce a 'New Order Available' message (and check in Bonita that a new instance of the payment process has been executed)

![Payment Service implemented with Bonita](https://github.com/nchabanoles/microservices-orchestration-talk/raw/master/pics/payment-process-microservice.png)

### Demo 3 (Bonita as Choreograph)

**Prerequisites**: Bonita server is running and the Order Management process has been installed. See [microservice-orchestration-bonita-order-process-example](https://github.com/nchabanoles/microservice-orchestration-bonita-order-process-example).

After Demo 2 has been played:
* Start the bonita-choreography container
* Open Bonita admin console to the see the process execution
* Re-start nodejs-orders-service container to produce a 'New Order Available' message (and check in Bonita that a new instance of the payment process has been executed)

![Choreography implemented with Bonita](https://github.com/nchabanoles/microservices-orchestration-talk/raw/master/pics/bonita-microservices-choreography.png)