Microservices Chain Pattern

These days lightsweight containers like Docker are getting traction, as more and more API services are developed for docker containers and deployed to the cloud. In this environment, traditional heavy weight containers like Java EE and Spring are losing ground as it doesn’t make sense to have a heavy weight container wrapped with a light weight docker container. Docker and container orchestration tools like Kubernetes and Docker Swarm are replacing all the functionalities Java EE provides without hogging resources.

There is an article published by Gartner indicates that both Java EE and .NET are declining and will be replaced very soon.

Another clear trend is standalone Gateway is phasing out in the cloud environment with docker containers as most of the traditional gateway features are replaced by container orchestration tool and docker container management tools. In addition, some of the cross cutting concerns gateway provided are addressed in API frameworks like light-4j and related light*4j frameworks.

This tutorial shows you how to build 4 services chained together one by one. And it will be the foundation for our microservices benchmarks.

API A -> API B -> API C -> API D

It is a very long tutorial as we want to package as much info as possible. So we have separated it into the following steps.

If you would like to gain a general understanding of how this application will work visit our Quick Start to read a step-by-step of how our pre-built Microservices Chain example works.

  1. Environment preparation

  2. Create specification

  3. Generate and Build

  4. Http Chain

  5. Performance with Http

  6. Https Chain

  7. Performance with Https

  8. Security

  9. Metrics

  10. Docker compose

  11. Docker compose performance

  12. Kubernetes

Preparation

2017-11-29T10:32:34-05:00 All specifications and code of the services are on github.com but we are going to redo it again by following the steps in the tutorial. Let’s first create a workspace. I have created a directory named networknt under user directory. Checkout related projects into your local workspace. cd ~/networknt git clone https://github.com/networknt/light-codegen.git git clone https://github.com/networknt/light-example-4j.git git clone https://github.com/networknt/model-config.git git clone https://github.com/networknt/light-oauth2.git git clone https://github.com/networknt/light-docker.git As we are going to regenerate API A, B, C and D, let’s rename ms_chain folder from light-example-4j so that we can compare with the standard implementation if something is not working. Read More »

Specification

Light*4j microservices frameworks encourage Design Driven API building. For the REST style of APIs we support the Swagger 2.0 specification and OpenAPI 3.0 specification. In this tutorial, we are going to use the Swagger 2.0 specification as the central piece to drive the runtime for security and validation. Also, the specification can be used to scaffold a running server project the first time so that developers can focus their efforts on the domain business logic implementation without worrying about how each component are wired together. Read More »

Generation

Now that we have four API swagger.yaml files available, let’s use light-codegen to start four projects in light-example-4j/rest/swagger/ms_chain. In a normal API build, you should create a repo for each API. For us, we have to user light-example-4j for all the examples and tutorial for easy management in networknt github organization. Build light-codegen The light-codegen project is cloned to the local already during the prepare stage. Let’s build it. cd ~/networknt/light-codegen mvn clean install -DskipTests Prepare Generator Config Each generator in light-codegen requires several parameters to control how the generator works. Read More »

Httpchain

Now that these APIs are working if you start them, they will output the mock responses generated based on the API specifications. Let’s take a look at the API handler itself and update it based on our business logic, you can call API A and subsequently all other APIs will be called in a chain. Prepare Environment Before starting this step, let’s create a folder called httpchain in each sub folder under ms_chain and copy everything from generated folder to the httpchain. Read More »

Httpperf

Now let’s see if these servers are performing with wrk. To learn how to use it, please see my article in tools here Assume you have wrk installed, run the following command. wrk -t4 -c128 -d30s http://localhost:7001 -s pipeline.lua --latency -- /v1/data 1024 And here is what I got on my i5 desktop wrk -t4 -c128 -d30s http://localhost:7001 -s pipeline.lua --latency -- /v1/data 1024 Running 30s test @ http://localhost:7001 4 threads and 128 connections Thread Stats Avg Stdev Max +/- Stdev Latency 0. Read More »

Httpschain

Now these APIs are working as a chain with Http connection. In this step, we are going to change the connection to Https and see what is the performance difference. Prepare Environment Before starting this step, let’s create a folder called httpschain in each sub folder under ms_chain and copy everything from httpchain folder to the httpschain. We are going to update httpschain folder to have connections switched to Https by changing the urls in config files. Read More »

Httpsperf

Now let’s see if these servers are performing with wrk. To learn how to use it, please see my article in tools here Assume you have wrk installed, run the following command. wrk -t4 -c128 -d30s http://localhost:7001 -s pipeline.lua --latency -- /v1/data 1024 And here is what I got on my i5 desktop wrk -t4 -c128 -d30s http://localhost:7001 -s pipeline.lua --latency -- /v1/data 1024 Running 30s test @ http://localhost:7001 4 threads and 128 connections Thread Stats Avg Stdev Max +/- Stdev Latency 0. Read More »

Security

So far, we’ve started four servers and tested them successfully with both Http and Https connections; however, these servers are not protected by OAuth2 JWT tokens as it is turned off by default in the generated code. Now let’s turn on the security and check the performance with JWT verification is on. Before we turn on the security, we need to have light-oauth2 server up and running so that these servers can get JWT token in real time. Read More »

Securityperf

Since we have both https and OAuth2 involved, we are going to test the performance again. wrk -t4 -c128 -d30s -H "Authorization: Bearer eyJraWQiOiIxMDAiLCJhbGciOiJSUzI1NiJ9.eyJpc3MiOiJ1cm46Y29tOm5ldHdvcmtudDpvYXV0aDI6djEiLCJhdWQiOiJ1cm46Y29tLm5ldHdvcmtudCIsImV4cCI6MTgxMzAwNTAzNiwianRpIjoiN2daaHY2TS14UXpvVDhuNVMxODNodyIsImlhdCI6MTQ5NzY0NTAzNiwibmJmIjoxNDk3NjQ0OTE2LCJ2ZXJzaW9uIjoiMS4wIiwidXNlcl9pZCI6IlN0ZXZlIiwidXNlcl90eXBlIjoiRU1QTE9ZRUUiLCJjbGllbnRfaWQiOiJmN2Q0MjM0OC1jNjQ3LTRlZmItYTUyZC00YzU3ODc0MjFlNzIiLCJzY29wZSI6WyJhcGlfYS53IiwiYXBpX2IudyIsImFwaV9jLnciLCJhcGlfZC53Iiwic2VydmVyLmluZm8uciJdfQ.FkFbPTRXZf045_7fBlEPQTn7rNoib54TYQeFzSjLmMkUjrfDsJZD6EnrsAquDpHt8GKQNqGbyPzgiNWAIYHgwPZvM-lHw_dv0KUKii3D0woaFBkqu4vYxqyImROBii0B38evxPAZVONWqUncL21592bFPHsxGCz5oHL2unLv-oIQklWxcILpMrSL_tf7nhXHSu1RkRhshxAiAHSSpBZnluu4-jqZdEFtc5U_YApToUrKkmI_An1op5-6rS_I-fMbSnSctUoDgg3RT4Zvw1HC-ZLJlXWRF5-FD4uQOAOgy_T7PI75pNiuh4wgOGgdIf48X-7-fDkEbla-cVLiuj3z4g" https://localhost:7441 -s pipeline.lua --latency -- /v1/data 1024 And result Running 30s test @ https://localhost:7441 4 threads and 128 connections Thread Stats Avg Stdev Max +/- Stdev Latency 0.00us 0.00us 0.00us -nan% Req/Sec 4.68k 4.11k 15.64k 56.64% Latency Distribution 50% 0.00us 75% 0.00us 90% 0.00us 99% 0.00us 235520 requests in 30. Read More »

Metrics

Enable Metrics Read More »

Logging

Currently Under Construction Read More »

Docker Compose

So far, we have four servers running and they can talk to each other as standalone services. In this step, we are going to dockerize all of them and start them with a docker-compose up command. Before doing that, let’s create two folders under ms_chain for different version of compose files and externalized config files. cd ~/networknt/light-example-4j/rest/swagger/ms_chain mkdir compose mkdir etc Now in the etc folder, we need to create sub folders for each api and config sub folder Read More »

Composeperf

Let’s run a load test now. wrk -t4 -c128 -d30s -H "Authorization: Bearer eyJraWQiOiIxMDAiLCJhbGciOiJSUzI1NiJ9.eyJpc3MiOiJ1cm46Y29tOm5ldHdvcmtudDpvYXV0aDI6djEiLCJhdWQiOiJ1cm46Y29tLm5ldHdvcmtudCIsImV4cCI6MTgxMzAwNTAzNiwianRpIjoiN2daaHY2TS14UXpvVDhuNVMxODNodyIsImlhdCI6MTQ5NzY0NTAzNiwibmJmIjoxNDk3NjQ0OTE2LCJ2ZXJzaW9uIjoiMS4wIiwidXNlcl9pZCI6IlN0ZXZlIiwidXNlcl90eXBlIjoiRU1QTE9ZRUUiLCJjbGllbnRfaWQiOiJmN2Q0MjM0OC1jNjQ3LTRlZmItYTUyZC00YzU3ODc0MjFlNzIiLCJzY29wZSI6WyJhcGlfYS53IiwiYXBpX2IudyIsImFwaV9jLnciLCJhcGlfZC53Iiwic2VydmVyLmluZm8uciJdfQ.FkFbPTRXZf045_7fBlEPQTn7rNoib54TYQeFzSjLmMkUjrfDsJZD6EnrsAquDpHt8GKQNqGbyPzgiNWAIYHgwPZvM-lHw_dv0KUKii3D0woaFBkqu4vYxqyImROBii0B38evxPAZVONWqUncL21592bFPHsxGCz5oHL2unLv-oIQklWxcILpMrSL_tf7nhXHSu1RkRhshxAiAHSSpBZnluu4-jqZdEFtc5U_YApToUrKkmI_An1op5-6rS_I-fMbSnSctUoDgg3RT4Zvw1HC-ZLJlXWRF5-FD4uQOAOgy_T7PI75pNiuh4wgOGgdIf48X-7-fDkEbla-cVLiuj3z4g" https://localhost:7441 -s pipeline.lua --latency -- /v1/data 1024 And the result. Running 30s test @ https://localhost:7441 4 threads and 128 connections Thread Stats Avg Stdev Max +/- Stdev Latency 0.00us 0.00us 0.00us -nan% Req/Sec 3.67k 2.92k 14.68k 57.75% Latency Distribution 50% 0.00us 75% 0.00us 90% 0.00us 99% 0.00us 252860 requests in 30.07s, 58.12MB read Socket errors: connect 0, read 0, write 0, timeout 128 Requests/sec: 8409. Read More »

Kubernetes

Currently Under Construction Read More »

Quick Start - Microservices Chain Application

This is the Quick Start tutorial that utilizes the pre-built repository to provide an introduction to MS Chain Services. If you prefer to do a step-by-step setup of MS Chain Services please visit the MS Chain Services Home You will need the following dependencies before starting this tutorial: Java JDK 11 (I prefer OpenJDK but Oracle JDK will do) Maven Git Docker This quick start tutorial is designed for anyone beginning to utilize Light-4j and wants to gain a general understanding of how to setup a microservice chain application utilizing four APIs. Read More »