A Curated Dataset of Microservices-Based Systems

Abstract

Microservices based architectures are based on a set of modular, independent and fault-tolerant services. In recent years, the software engineering community presented studies investigating potential, recurrent, e ective architectural patterns in microservices-based architectures, as they are very essential to maintain and scale microservice-based systems. Indeed, the organizational structure of such systems should be re ected in so-called microservice architecture patterns, that best t the projects and development teams needs. However, there is a lack of public repositories sharing open sources projects microservices patterns and practices, which could be bene cial for teaching purposes and future research investigations. This paper tries to ll this gap, by sharing a dataset, having a rst curated list microservice-based projects. Speci cally, the dataset is composed of 20 open-source projects, all using speci c microservice architecture patterns. Moreover, the dataset also reports information about inter-service calls or dependencies of the aforementioned projects. For the analysis, we used two di erent tools (1) SLOCcount and (2) MicroDepGraph to get di erent parameters for the microservice dataset. Both the microservice dataset and analysis tool are publicly available online. We believe that this dataset will be highly used by the research community for understanding more about microservices architectural and dependencies patterns, enabling researchers to compare results on common projects.

Keywords

• First keyword Second keyword Another keyword

-

Microservices based architectures are based on a set of modular, independent and fault-tolerant services, which are ideally easy to be monitored and tested [ 6 ], and can be easily maintained [ 15 ] by integrating also user feedback in the loop [ 9,4 ]. However, in practice, decomposing a monolithic system into independent microservices is not a trivial task [ 20 ], which is typically performed manually by software architects [ 15,13 ], without the support of tool automating the decomposition or slicing phase [ 15 ]. To ease the identi cation of microservices in monolithic applications, further empirical investigations need to be performed and automated tools (e.g., based on summarization techniques [ 8 ]) need to be provided to developers, to make this process more reliable and e ective [ 16 ].

In recent years, the software engineering community presented studies investigating the potential, recurrent, e ective architectural patterns [ 15,16 ] and anti-patterns [ 14,18,19 ] in microservices-based architectures. Indeed, the organizational structure of such systems should be re ected in so-called microservice architecture patterns, that best t the projects and development teams needs. However, there is a lack of public repositories sharing open sources projects microservices patterns and practices, which could be bene cial for teaching purposes and future research investigations.

This paper tries to ll this gap, by sharing a dataset, having a rst curated list of open-source microservice-based projects. Speci cally, the dataset is composed of 20 open-source projects, all using speci c microservice architecture patterns. Moreover, the dataset also reports information about inter-service calls or dependencies of the aforementioned projects. For the analysis, we used two di erent tools such as (1) SLOCcount and (2) MicroDepGraph. The microservice dataset [ 10 ] and analysis tool [ 11 ] are publicly available online, and detailed in the following sections.

At the best of our knowledge only Marquez and Hastudillo proposed a dataset of microservices-based projects [ 7 ]. However, their goal was the investigation of architectural patterns adopted by the microservices-based projects, and they did not provided dependency graphs of the services.

We believe that this dataset will be highly used by the research community for understanding more about microservices architectural and dependencies patterns, enabling researchers to compare results on common projects.

Paper structure. In Section 2, we discuss the main background of this work, focusing on the open challenges concerning understanding an analyzing microservices-based architectures. In Section 3, we discuss the projects selection strategy, while in Section4 are described the data extraction process (describing the tools used and implemented for it) and the generated data. Finally, Section 6 and Section 7, discuss the main threats of concerning the generation of the generated dataset, concluding the paper outline future directions. 2

Background

In recent years, the software industry especially the enterprise software are rapidly adopting the Microservice architectural pattern. Compared to a serviceoriented architecture, the microservice architecture is more decoupled, independently deployable and also horizontally scalable. In microservices, each service can be developed using di erent languages and frameworks. Each service is deployed to their dedicated environment whatever e cient for them. The communication between the services can be either REST or RPC calls. So that whenever there is a change in business logic in any of the services others are not a ected as long as the communication endpoint is not changed. As a result, if any of the components of the system fails, it will not a ect the other components or services, which is a big drawback of monolithic system [ 5 ]. The clear separation of tasks between teams developing microservices also enable teams to deploy independently. Another bene t of microservices is that the usage of DevOps is simpli es [ 17 ]. The drawback, is the increased initial development e ort, due to the connection between services [ 12 ].

As we can see in Figure 1, components in monolithic systems are tightly coupled with each other so that the failure of one component will a ect the whole system. Also if there are any architectural changes in a monolithic system it will a ect other components. Due to these advantages, microservice architecture is way more e ective and e cient than monolithic systems. Instead of having lots of good features of microservice, implementing and managing microservice systems are still challenging and require highly skilled developers [ 1 ].

Service ts Aunccoountcs

c A

Products Recommender

Orders Monolithic System

Data Access

Database

API Gatway

Message

Broker u A Cetsntrnal mcooncitoring tsCenuntraollogcAging

c t u c A AcscounntsoSercvice Products Services Recomm.Services Orders Services Microservices-based System We selected projects from GitHub, searching projects implemented with a microservicebased architecture, developed in Java and using docker.

The search process was performed applying the following search string: "micro-service" OR microservice OR "micro-service" filename:Dockerfile language:Java

Results of this query reported 18,639 repository results mentioning these keywords.

We manually analyzed the rst 1000 repositories, selecting projects implemented with a microservice-architectural style and excluding libraries, tools to support the development including frameworks, databases, and others.

Then, we created a github page to report the project list [ 10 ] and we opened several questions on di erent forums3 4. Moreover, we monitored replies to similar questions on other practitioners forums5 6 7 8 to ask practitioners if they were aware of other relevant Open Source projects implemented with a microservicearchitectural style. We received 19 replies from the practitioners' forums, recommending to add 6 projects to the list. Moreover, four contributors send a pull request to the repository to integrate more projects.

In this work, we selected the top 20 repositories that ful ll our requirements.

The complete list of projects is available in Table 1 and can be downloaded from the repository GitHub page [ 11 ].

https://www.researchgate.net/post/Do_you_know_any_

Open_Source_project_that_migrated_form_a_monolithic_architecture_to_

3 ResearchGate.

microservices

4 Stack

Over ow -1

https://stackoverflow.com/questions/48802787/open5 Stack Over ow -2 https://stackoverflow.com/questions/37711051/example6 Stack Over ow -3 https://www.quora.com/Are-there-any-examples-of-open7 Quora -1

https://www.quora.com/Are-there-any-open-source-projectsthat-I-can-see-the-details

Data Collection

We analyzed di erent aspects of the projects. We rst considered the size of the systems, analyzing the size of each microservices in Lines of code. The analysis was performed by applying the SLOCCount tool9.

Then we analyzed the dependencies between services by applying the MicroDepGraph tool [ 11 ] developed by one of the authors. 4.1

SLOCcount

SLOCcount is an open source tool for counting the e ective lines of code of an application. It can be executed on several development languages, and enable to quickly count the lines of code in di erent directories. 4.2

MicroDepGraph

MicroDepGraph is our in-house tool developed for detecting dependencies and plot the dependency graph of microservices.

Starting from the source code of the di erent microservices, it analyzes the docker les for service dependencies de ned in docker-compose and java source code for internal API calls. The tool is completely written in Java. It takes two parameters as input: (1) the path of the project in the local disk and (2) the name of the project

We chose to analyze docker-compose les because, in microservices projects, the dependencies of the services are described in the docker-compose le as con guration. As the docker-compose is a YML or YAML le so the tool parses the les from the projects. MicroDepGraph rst determines the services of the microservices project de ned in the docker-compose le. Then for each service, it checks dependencies and maps the dependencies for respective services.

Analyzing only the docker-compose le does not give us all relationships of the dependencies, as there might be internal API call, for example, using a REST client. For this reason, we had to analyze the java source code for possible API calls to other services. As we are analyzing Java microservices project, the most commonly used and popular framework for building microservices in java is Spring Boot. In spring boot the API endpoints for services are con gured and de ned using di erent annotations in java source code. So we targeted these annotations when parsing java source code. First, we determined the endpoints for each service by parsing the java source code and looking for the annotations that de ne the endpoints. For parsing Java source code we used an open source library called JavaParser10. After getting endpoints for each service we searched whether there are any API calls made from other services using these endpoints. Then if there is an API call of one service from another, we map it as a dependency and add it to our nal graph. After nding all the mapping the

9 SLOCcount. https://dwheeler.com/sloccount/

10 JavaParser. https://javaparser.org/ tool then makes relationships(dependencies) between the services and draws a directed graph.

Finally, it generates a graph representation formatted as GraphML le, a neo4j database containing all the relationships and an svg le containing the graph.

Figure 2 shows an example of the output provided by MicroDepGraph on the project "Tap And Eat". 5

Dataset production and Structure

For each project, we rst cloned the repository. Then we executed SLOCcount independently on each project to extract the number of lines of code. Then we executed MicroDepGraph to obtain the dependencies between the microservices. From MicroDepGraph we got GraphML and svg le for each project. To generate GraphML le we used Apache TinkerPop11 graph computing framework. The GraphML le is easy to use xml based le where we can specify directed or undirected graphs and di erent attributes to the graph. Moreover, we can import the GraphML le in di erent graph visualization platforms like Gephi12. In this kind of graph visualization tools we can then apply di erent graph algorithms for further analyzing the graph. We also get SVG image as output so that it can be easily used for further processing.

Finally, we stored the results in a Github repository [ 10 ] as graphml les, together with the list of analyzed microservice projects. Below is an output of one of the projects analyzed by MicroDepGraph including the GraphML output, 1 <? xml version =" 1.0 " encoding ="UTF -8 "? > 2 < graphml xmlns =" http: // graphml . graphdrawing . org / xmlns " xmlns:xsi =" http: // www . w3 . org /2001/ XMLSchema - instance " xsi:schemaLocation =" http: // graphml . graphdrawing . org / xmlns http: // graphml . graphdrawing . org / xmlns /1.1/ graphml . xsd " > 3 <key id =" edgelabel " for =" edge " attr . name =" edgelabel " attr .

type =" string " / > 11 Apache TinkerPop http://tinkerpop.apache.org/ 12 Gephi https://gephi.org/ 4 <graph id="G" edgedefault =" directed "> 5 <node id=" stores " /> 6 <node id=" configserver " /> 7 <node id=" accounts " /> 8 <node id=" customers " /> 9 <node id=" prices " /> 10 <edge id=" stores -& gt; configserver " source =" stores " target =" configserver " label =" depends "> 11 <data key =" edgelabel ">depends </ data > 12 </ edge > 13 <edge id=" accounts -& gt; configserver " source =" accounts " target =" configserver " label =" depends "> 14 <data key =" edgelabel ">depends </ data > 15 </ edge > 16 <edge id=" customers -& gt; configserver " source =" customers " target =" configserver " label =" depends "> 17 <data key =" edgelabel ">depends </ data > 18 </ edge > 19 <edge id=" prices -& gt; configserver " source =" prices " target =" configserver " label =" depends "> 20 <data key =" edgelabel ">depends </ data > 21 </ edge > 22 </ graph > 23 </ graphml >

Listing 1.1: GraphML le

License. The dataset has been developed only for research purposes. It includes data elaborated and extracted from public repositories. Information from GitHub is stored under GitHub Terms of Service (GHTS), which explicitly allow extracting and redistributing public information for research purposes13.

The dataset is licensed under a Creative Commons Attribution-NonCommercialShareAlike 4.0 International license.

6 Threats to Validity

We are aware that both SLOCcount and MicroDepGraph might analyze the projects incorrectly under some conditions. Moreover, regarding SLOCcount we analyzed only the Java lines of code. We are aware that some project could contain also code written in other language or that the tool could provide incorrect results.

Another important threat is related to the generalization of the dataset. We selected the list of projects based on di erent criteria (see Section 3). Moreover, several projects are toy-projects or teaching examples and they cannot possibly represent the whole open-source ecosystem. Moreover, since the dataset does not include industrial projects, we cannot make any speculation on closed-source projects.

Conclusion

In this paper, we presented a curated dataset for microservices-based systems. To analyze the microservices projects we developed a tool(MicroDepGraph) to determine the dependencies of services in the microservices project.

We analyzed 20 open source microservice projects which include both demo and industrial projects. The number of services in the projects ranges from 5 to 25. To analyze dependencies we considered docker and internal API calls. Due to the docker analysis, this tool can analyze any microservice system that uses docker environment regardless of programming languages or frameworks. But for the API call, it will only analyze the projects implemented using Spring framework. As Spring framework is widely used for developing microservice systems. The dataset is provided as GraphML and SVG les for further analysis.

The output of the tool will allow researchers as well as companies to analyze the dependencies between each service in microservice project so that they can improve the architecture of the system. Moreover, di erent considerations and analysis could be performed with this dataset. As example, researchers could de ne and validate metrics for microservices [ 2 ] or investigate security aspects such as the risk of information propagation in the services[ 3 ].

We are planning to extend the tool so that it can analyze microservices developed in any framework and programming language. Also, we can use machine learning approach to identify di erent parameters and anomalies in the architecture of microservice systems. Moreover, we are planning to calculate quality metrics for microservices, based on [ 21,2 ]

References

1. Balalaie , A. , Heydarnoori , A. , Jamshidi , P. : Microservices architecture enables devops: Migration to a cloud-native architecture . IEEE Software 33(3) , 42 {52 (May 2016 ). https://doi.org/10.1109/MS. 2016 .64

2. Bogner , J. , Wagner , S. , Zimmermann , A. : Automatically measuring the maintainability of service- and microservice-based systems: A literature review . In: Proceedings of the 27th International Workshop on Software Measurement and 12th International Conference on Software Process and Product Measurement . pp. 107 { 115 . IWSM Mensura ' 17 , ACM , New York, NY, USA ( 2017 ). https://doi.org/10.1145/3143434.3143443, http://doi.acm. org/10 .1145/ 3143434.3143443

3. Carminati , B. , Ferrari , E. , Morasca , S. , Taibi , D.: A probability-based approach to modeling the risk of unauthorized propagation of information in on-line social networks . In: Proceedings of the First ACM Conference on Data and Application Security and Privacy . pp. 51 { 62 . CODASPY '11, ACM , New York, NY, USA ( 2011 ). https://doi.org/10.1145/1943513.1943522, http://doi.acm. org/10 .1145/ 1943513.1943522

4. Grano , G. , Ciurumelea , A. , Panichella , S. , Palomba , F. , Gall , H.C. : Exploring the integration of user feedback in automated testing of android applications . In: SANER . pp. 72 { 83 . IEEE Computer Society ( 2018 )

5. Lewi , J. , Fowler , M. : Microservices. www.martinfowler.com/articles/microservices.html ( 2014 )

6. Martin , D. , Panichella , S.: The cloudi cation perspectives of search-based software testing . In: SBST@ICSE . pp. 5 { 6 . IEEE / ACM ( 2019 )

7. Marquez , G. , Astudillo , H.: Actual use of architectural patterns in microservicesbased open source projects . In: 2018 25th Asia-Paci c Software Engineering Conference (APSEC) . pp. 31 { 40 (Dec 2018 ). https://doi.org/10.1109/APSEC. 2018 .00017

8. Panichella , S. : Summarization techniques for code, change, testing, and user feedback (invited paper) . In: VST@SANER . pp. 1 { 5 . IEEE ( 2018 )

9. Panichella , S. , Sorbo , A.D. , Guzman , E. , Visaggio , C.A. , Canfora , G. , Gall , H.C. : How can i improve my app? classifying user reviews for software maintenance and evolution . In: ICSME. pp. 281 { 290 . IEEE Computer Society ( 2015 )

10. Rahman , M. , Taibi , D. : Microservice dataset . https://github.com/clowee/ MicroserviceDataset ( 2019 )

11. Rahman , M. , Taibi , D. : Microservice dependency graph (microdepgraph) . https: //github.com/clowee/MicroDepGraph ( 2019 )

12. Saarimaki, N., Lomio , F. , Lenarduzzi , V. , Taibi , D. : Does Migrate a Monolithic System to Microservices Decreases the Technical Debt ? arXiv e-prints arXiv: 1902 . 06282 ( Feb 2019 )

13. Soldani , J. , Tamburri , D.A. , Heuvel , W.J.V.D.: The pains and gains of microservices: A systematic grey literature review . Journal of Systems and Software 146 , 215 { 232 ( 2018 )

14. Taibi , D. , Lenarduzzi , V.: On the de nition of microservice bad smells . IEEE Software 35(3) , 56 { 62 ( 2018 )

15. Taibi , D. , Lenarduzzi , V. , Pahl , C. : Processes, motivations, and issues for migrating to microservices architectures: An empirical investigation . IEEE Cloud Computing 4 ( 5 ), 22 { 32 ( 2017 )

16. Taibi , D. , Lenarduzzi , V. , Pahl , C. : Architectural patterns for microservices: a systematic mapping study . 8th International Conference on Cloud Computing and Services Science (CLOSER2018) ( 2018 )

17. Taibi , D. , Lenarduzzi , V. , Pahl , C. : Continuous architecting with microservices and devops: A systematic mapping study . In: Mun~oz, V.M. , Ferguson , D. , Helfert , M. , Pahl , C. (eds.) Cloud Computing and Services Science . pp. 126 { 151 . Springer International Publishing, Cham ( 2019 )

18. Taibi , D. , Lenarduzzi , V. , Pahl , C. : Microservices anti-patterns: A taxonomy . Microservices - Science and Engineering . Springer. 2019 ( 2019 )

19. Taibi , D. , Lenarduzzi , V. , Pahl , C. : Microservices architectural, code and organizational anti-patterns . Cloud Computing and Services Science . CLOSER 2018 Selected papers . Communications in Computer and Information Science pp. 126 { 151 ( 2019 )

20. Taibi , D. , Lenarduzzi , V. , Pahl , C. , Janes , A. : Microservices in agile software development: a workshop-based study into issues, advantages, and disadvantages . In: XP Workshops . pp. 23 : 1 { 23 : 5 . ACM ( 2017 )

21. Taibi , D. , Systa , K. : From monolithic systems to microservices: A decomposition framework based on process mining . In: 9th International Conference on Cloud Computing and Services Science , CLOSER , 2019 . Heraklion (Greece) ( 05 / 2019 2019)