Resilience Engineering for Cloud-Deployed Financial Systems Using Spring-Based Microservices
DOI:
https://doi.org/10.22399/ijcesen.5546Keywords:
Resilience engineering, Spring Boot microservices, cloud-native finance, distributed transaction integrity, observabilityAbstract
Financial systems deployed on clouds are more and more based on microservice architectures to enable rapid delivery, elastic scaling, and modular evolution, but on complex networks of inter-service dependencies, asynchronous workflows and cloud orchestration layers, the same architectures spread operational risk widely. This review discusses the application of resilience engineering across financial systems that are deployed using Spring-based microservices, with a focus on fault isolation, transaction integrity, observability, adaptive scaling, and controlled degradation. The structured review method was used to analyse peer-reviewed journal articles and academic books on software architecture, distributed systems, cloud computing, dependability and financial information systems. The literature review suggests that fault-tolerance patterns alone cannot be used to achieve financial microservice resilience. The resilience dictates that the service decomposition is limited, explicit control of the boundaries of transactions, strict idempotency, business process-related observability, and experimentally demonstrated resilience to realistic faults. Common cloud-native mechanisms that have been demonstrated include retries, circuit breakers, autoscaling and asynchronous messaging, which give mixed results when used without consideration of financial correctness constraints. The Spring ecosystem provides a disciplined implementation and runtime substrate for resilience mechanisms, but its effectiveness depends on rigorous configuration, verification, and domain-aware design. The key research gaps include the lack of finance-grade resilience measurements, limited comparative information on patterns efficacy, and technical telemetry and business-level accuracy measurements. Formalization of financial invariants, domain-sensitive adaptive control and testing proving semantic correctness in the event of failure and continuation of the services should be the main directions of the future work.
References
[1] Haldane, A. G., & May, R. M. (2011). Systemic risk in banking ecosystems. Nature, 469(7330), 351–355. DOI: https://doi.org/10.1038/nature09659
[2] Arner, D. W., Barberis, J. N., & Buckley, R. P. (2016). The evolution of Fintech: A new post-crisis paradigm? Georgetown Journal of International Law, 47(4), 1271–1319. DOI: https://doi.org/10.2139/ssrn.2676553
[3] Bass, L., Clements, P., & Kazman, R. (2013). Software architecture in practice (3rd ed.). Addison-Wesley.
[4] Newman, S. (2021). Building microservices (2nd ed.). O’Reilly Media.
[5] Dragoni, N., Giallorenzo, S., Lafuente, A. L., Mazzara, M., Montesi, F., Mustafin, R., & Safina, L. (2017). Microservices: Yesterday, today, and tomorrow. In M. Mazzara & B. Meyer (Eds.), Present and ulterior software engineering (pp. 195–216). Springer. DOI: https://doi.org/10.1007/978-3-319-67425-4_12
[6] Nygard, M. T. (2018). Release it!: Design and deploy production-ready software (2nd ed.). Pragmatic Bookshelf.
[7] Kleppmann, M. (2017). Designing data-intensive applications. O’Reilly Media.
[8] Allspaw, J. (2015). Trade-offs under pressure: Heuristics and observations of teams resolving internet service outages. Journal of Cognitive Engineering and Decision Making, 9(4), 359–372. DOI: https://doi.org/10.1177/1555343415616125
[9] Hollnagel, E. (2011). Prologue: The scope of resilience engineering. In E. Hollnagel, J. Pariès, D. D. Woods, & J. Wreathall (Eds.), Resilience engineering in practice: A guidebook (pp. xxix–xxxix). Ashgate.
[10] Woods, D. D. (2015). Four concepts for resilience and the implications for the future of resilience engineering. Reliability Engineering & System Safety, 141, 5–9. DOI: https://doi.org/10.1016/j.ress.2015.03.018
[11] Johnson, R., Hoeller, J., Arendsen, A., Risberg, T., Sampaleanu, C., Evans, W., Harrop, R., & Dale, T. (2012). Professional Java development with the Spring Framework. Wrox.
[12] Carnell, J. (2021). Spring microservices in action (2nd ed.). Manning.
[13] Tanenbaum, A. S., & van Steen, M. (2017). Distributed systems (3rd ed.). CreateSpace.
[14] Coulouris, G., Dollimore, J., Kindberg, T., & Blair, G. (2012). Distributed systems: Concepts and design (5th ed.). Addison-Wesley.
[15] Richards, M. (2015). Microservices vs. service-oriented architecture. O’Reilly Media.
[16] Taibi, D., Lenarduzzi, V., & Pahl, C. (2020). Processes, motivations, and issues for migrating to microservices architectures: An empirical investigation. IEEE Cloud Computing, 7(5), 22–32. DOI: https://doi.org/10.1109/MCC.2017.4250931
[17] Jansen, F. (2014). Towards cloud-native applications. In M. Villari, W. Zimmermann, K.-K. Lau, & S. Dustdar (Eds.), European Conference on Service-Oriented and Cloud Computing Workshops (pp. 1–12). Springer.
[18] Burns, B., Grant, B., Oppenheimer, D., Brewer, E., & Wilkes, J. (2016). Borg, Omega, and Kubernetes. Communications of the ACM, 59(5), 50–57. DOI: https://doi.org/10.1145/2890784
[19] Laprie, J.-C. (2008). From dependability to resilience. In 38th IEEE/IFIP International Conference on Dependable Systems and Networks Workshop on Resilience of Networks and Distributed Systems (pp. G8–G9). IEEE.
[20] Basiri, A., Behnam, N., de Rooij, R., Hochstein, L., Kosewski, L., Reynolds, J., & Rosenthal, C. (2016). Chaos engineering. IEEE Software, 33(3), 35–41. DOI: https://doi.org/10.1109/MS.2016.60
[21] Gozman, D., Hedman, J., & Olson, M. (2018). Digital transformation of financial institutions. Journal of Management Information Systems, 35(4), 1045–1055.
[22] Weber, B. W. (2010). The effects of procedural fairness and trust on compliance with regulations. Journal of Management Information Systems, 27(1), 129–160.
[23] Fowler, M., & Lewis, J. (2014). Microservices: A definition of this new architectural term. In M. Fowler (Ed.), Patterns of enterprise application architecture revisited (expanded essays). Addison-Wesley.
[24] Sam Newman, S. (2019). Monolith to microservices. O’Reilly Media.
[25] Di Francesco, P., Lago, P., & Malavolta, I. (2019). Architecting with microservices: A systematic mapping study. Journal of Systems and Software, 150, 77–97. DOI: https://doi.org/10.1016/j.jss.2019.01.001
[26] Soldani, J., Tamburri, D. A., & van den Heuvel, W.-J. (2018). The pains and gains of microservices: A systematic grey literature review. Journal of Systems and Software, 146, 215–232. DOI: https://doi.org/10.1016/j.jss.2018.09.082
[27] Knoche, H., & Hasselbring, W. (2018). Using microservices for legacy software modernization. IEEE Software, 35(3), 44–49. DOI: https://doi.org/10.1109/MS.2018.2141035
[28] Fritzsch, J., Bogner, J., Zimmermann, A., & Wagner, S. (2019). From monolith to microservices: A classification of refactoring approaches. In Software engineering aspects of continuous development and new paradigms of software production and deployment (pp. 128–141). Springer. DOI: https://doi.org/10.1007/978-3-030-06019-0_10
[29] Brewer, E. A. (2012). CAP twelve years later: How the “rules” have changed. Computer, 45(2), 23–29. DOI: https://doi.org/10.1109/MC.2012.37
[30] Gilbert, S., & Lynch, N. (2012). Perspectives on the CAP theorem. Computer, 45(2), 30–36. DOI: https://doi.org/10.1109/MC.2011.389
[31] Richardson, C. (2019). Microservices patterns. Manning.
[32] Helland, P. (2007). Life beyond distributed transactions: An apostate’s opinion. Communications of the ACM, 50(2), 38–42.
[33] Adzic, G., & Chatley, R. (2017). Serverless computing: Economic and architectural impact. In Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering (pp. 884–889). ACM. DOI: https://doi.org/10.1145/3106237.3117767
[34] Burns, B., Beda, J., Hightower, K., & Evans, L. (2022). Kubernetes: Up and running (3rd ed.). O’Reilly Media.
[35] Fehling, C., Leymann, F., Retter, R., Schupeck, W., & Arbitter, P. (2014). Cloud computing patterns. Springer. DOI: https://doi.org/10.1007/978-3-7091-1568-8
[36] Rosner, F., & Leitner, P. (2023). A survey of resilience design patterns for cloud-native applications. ACM Computing Surveys, 55(13s), 1–39. DOI: https://doi.org/10.1145/3578516
[37] Hollnagel, E. (2014). Safety-I and Safety-II: The past and future of safety management. Ashgate.
[38] Woods, D. D., & Branlat, M. (2011). Hollnagel’s test: Being “in control” of highly interdependent multi-layered networked systems. Cognition, Technology & Work, 13(2), 95–101. DOI: https://doi.org/10.1007/s10111-010-0144-5
[39] Gunawi, H. S., Hao, M., Leesatapornwongsa, T., Patana-anake, C., Do, T., Adityatama, J., Eliazar, K. J., & Laksono, A. B. (2014). What bugs live in the cloud? A study of 3000+ issues in cloud systems. In Proceedings of the ACM Symposium on Cloud Computing (pp. 1–14). ACM. DOI: https://doi.org/10.1145/2670979.2670986
[40] Salehie, M., & Tahvildari, L. (2009). Self-adaptive software: Landscape and research challenges. ACM Transactions on Autonomous and Adaptive Systems, 4(2), 1–42. DOI: https://doi.org/10.1145/1516533.1516538
[41] Kokkola, T. (Ed.). (2010). The payment system: Payments, securities and derivatives, and the role of the Eurosystem. European Central Bank.
[42] Brummer, C., & Yadav, Y. (2019). Fintech and the innovation trilemma. Georgetown Law Journal, 107(2), 235–307.
[43] Moosa, I. A. (2007). Operational risk: A survey. Financial Markets, Institutions & Instruments, 16(4), 167–200. DOI: https://doi.org/10.1111/j.1468-0416.2007.00123.x
[44] Walls, C. (2022). Spring in action (6th ed.). Manning.
[45] Deinum, M. (2017). Spring Boot 2 recipes. Apress. DOI: https://doi.org/10.1007/978-1-4842-3963-6
[46] Sharma, K. (2019). Spring 5.0 microservices (2nd ed.). Packt.
[47] Dean, J., & Barroso, L. A. (2013). The tail at scale. Communications of the ACM, 56(2), 74–80. DOI: https://doi.org/10.1145/2408776.2408794
[48] Al-Dhuraibi, Y., Paraiso, F., Djarallah, N., & Merle, P. (2017). Elasticity in cloud computing: State of the art and research challenges. IEEE Transactions on Services Computing, 11(2), 430–447. DOI: https://doi.org/10.1109/TSC.2017.2711009
[49] Tseitlin, A. (2013). The antifragile organization. Communications of the ACM, 56(8), 40–44. DOI: https://doi.org/10.1145/2492007.2492022
[50] Kleppmann, M., & Kreps, J. (2017). Kafka, Samza and the Unix philosophy of distributed data. IEEE Data Engineering Bulletin, 40(1), 33–44. DOI: https://doi.org/10.1007/978-3-319-63962-8_197-1
[51] Skelton, M., & Pais, M. (2019). Team topologies. IT Revolution.
[52] Gan, Y., Zhang, Y., Hu, K., Ramakrishnan, K. K., & Xi, C. (2019). An open-source benchmark suite for microservices and their hardware-software implications for cloud and edge systems. ACM SIGPLAN Notices, 54(4), 3–18. DOI: https://doi.org/10.1145/3297858.3304013
[53] Luo, X., Zhang, J., Krintz, C., Wolski, R., & Tumanov, A. (2021). Automated fault injection for cloud systems. Future Generation Computer Systems, 116, 272–285. DOI: https://doi.org/10.1016/S0167-739X(20)33054-5
[54] Bogner, J., Fritzsch, J., Wagner, S., & Zimmermann, A. (2021). Assuring the evolvability of microservices: Insights into industry practices and challenges. Journal of Software: Evolution and Process, 33(3), e2312.
[55] Hasselbring, W., & Steinacker, G. (2017). Microservice architectures for scalability, agility and reliability in e-commerce. In 2017 IEEE International Conference on Software Architecture Workshops (pp. 243–246). IEEE. DOI: https://doi.org/10.1109/ICSAW.2017.11
[56] Barros, A., Dumas, M., & ter Hofstede, A. H. M. (2005). Service interaction patterns. In Business process management (pp. 302–318). Springer. DOI: https://doi.org/10.1007/11538394_20
[57] Kephart, J. O., & Chess, D. M. (2003). The vision of autonomic computing. Computer, 36(1), 41–50. DOI: https://doi.org/10.1109/MC.2003.1160055
[58] Menascé, D. A. (2002). QoS issues in web services. IEEE Internet Computing, 6(6), 72–75. DOI: https://doi.org/10.1109/MIC.2002.1067740
[59] Brintrup, A., Ledwoch, A., Barros, J., & Mahundla, K. (2018). Topological robustness of the global automotive industry. Logistics Research, 11(1), 1–17. DOI: https://doi.org/10.1007/s12159-015-0128-1
[60] Garcia-Molina, H., & Salem, K. (1987). Sagas. ACM SIGMOD Record, 16(3), 249–259. DOI: https://doi.org/10.1145/38714.38742
[61] Garlan, D., Cheng, S.-W., Huang, A.-C., Schmerl, B., & Steenkiste, P. (2004). Rainbow: Architecture-based self-adaptation with reusable infrastructure. Computer, 37(10), 46–54. DOI: https://doi.org/10.1109/MC.2004.175
[62] Vukotic, A., Goodwill, N., & Nikolic, D. (2018). Spring 5.0 by example. Packt.
[63] Steindl, G., Strembeck, M., & Sonntag, M. (2021). Quality assurance for microservices: A systematic mapping study. Information and Software Technology, 137, 106600. DOI: https://doi.org/10.1016/j.infsof.2021.106600
[64] Evans, E. (2003). Domain-driven design: Tackling complexity in the heart of software. Addison-Wesley.
[65] Vernon, V. (2013). Implementing domain-driven design. Addison-Wesley.
[66] Dragoni, N., Dustdar, S., Larsen, S. T., & Mazzara, M. (2019). Microservices: Migration of a mission critical system. IEEE Software, 35(3), 70–77.
[67] Pahl, C., Jamshidi, P., & Zimmermann, O. (2020). Architectural principles for cloud software. ACM Transactions on Internet Technology, 20(2), 1–23. DOI: https://doi.org/10.1145/3104028
[68] Gray, J., & Reuter, A. (1992). Transaction processing: Concepts and techniques. Morgan Kaufmann.
[69] Pat Helland. (2016). Building on quicksand. Communications of the ACM, 58(8), 42–49. DOI: https://doi.org/10.1145/2909466
[70] Fowler, M. (2005). Event sourcing. In Patterns of enterprise application architecture (supplementary essays). Addison-Wesley.
[71] Sigelman, B. H., Barroso, L. A., Burrows, M., Stephenson, P., Plakal, M., Beaver, D., Jaspan, S., & Shanbhag, C. (2010). Dapper, a large-scale distributed systems tracing infrastructure. Technical foundations republished in Communications of the ACM collections, 53(10), 1–13.
[72] Beyer, B., Jones, C., Petoff, J., & Murphy, N. R. (2016). Site reliability engineering. O’Reilly Media.
[73] Turnbull, J. (2014). The art of monitoring. James Turnbull.
[74] Chen, N., Cardoza, M., & Wang, Q. (2021). Root cause localization for cloud-native systems: A survey. Journal of Systems and Software, 182, 111065.
[75] Lorido-Botran, T., Miguel-Alonso, J., & Lozano, J. A. (2014). A review of auto-scaling techniques for elastic applications in cloud environments. Journal of Grid Computing, 12(4), 559–592. DOI: https://doi.org/10.1007/s10723-014-9314-7
[76] Herbst, N. R., Kounev, S., & Reussner, R. (2013). Elasticity in cloud computing: What it is, and what it is not. In Proceedings of the 10th International Conference on Autonomic Computing (pp. 23–27). USENIX.
[77] Klein, G., Woods, D. D., Bradshaw, J. M., Hoffman, R. R., & Feltovich, P. J. (2004). Ten challenges for making automation a “team player” in joint human-agent activity. IEEE Intelligent Systems, 19(6), 91–95. DOI: https://doi.org/10.1109/MIS.2004.74
[78] Sharma, P., Chaufournier, L., Shenoy, P., & Tay, Y. C. (2016). Containers and virtual machines at scale: A comparative study. Proceedings of the 17th International Middleware Conference, 1–13. DOI: https://doi.org/10.1145/2988336.2988337
[79] Namiot, D., & Sneps-Sneppe, M. (2014). On micro-services architecture. International Journal of Open Information Technologies, 2(9), 24–27.
[80] Milne, A. (2007). What is in it for us? Network effects and bank payment innovation. Journal of Banking Regulation, 8(2), 96–109. DOI: https://doi.org/10.2139/ssrn.1018590
[81] Wert, A., Aßmann, U., & Färber, M. (2021). Microservice benchmark suites: The state of the art. Future Generation Computer Systems, 125, 553–573.
[82] Kratzke, N., & Quint, P.-C. (2017). Understanding cloud-native applications after 10 years of cloud computing. Journal of Systems and Software, 126, 1–16. DOI: https://doi.org/10.1016/j.jss.2017.01.001
[83] Henzinger, T. A., & Sifakis, J. (2007). The discipline of embedded systems design. Computer, 40(10), 32–40. DOI: https://doi.org/10.1109/MC.2007.364
[84] Leucker, M., & Schallhart, C. (2009). A brief account of runtime verification. The Journal of Logic and Algebraic Programming, 78(5), 293–303. DOI: https://doi.org/10.1016/j.jlap.2008.08.004
[85] Laprie, J.-C. (1995). Dependable computing and fault tolerance: Concepts and terminology. In Proceedings of the 15th International Symposium on Fault-Tolerant Computing (pp. 2–11). IEEE. DOI: https://doi.org/10.1109/FTCSH.1995.532603
[86] Bonér, J., Farley, D., Kuhn, R., & Thompson, M. (2014). The reactive manifesto. In Reactive systems essays. O’Reilly Media.
[87] Toffetti, G., Brunner, S., Blöchlinger, M., Dudouet, F., & Edmonds, A. (2017). An architecture for self-managing microservices applications. In Proceedings of the 1st International Workshop on Automated Incident Management in Cloud (pp. 19–24). ACM. DOI: https://doi.org/10.1145/2747470.2747474
[88] Dekker, S. (2011). Drift into failure: From hunting broken components to understanding complex systems. Ashgate.
[89] Perrow, C. (1984). Normal accidents: Living with high-risk technologies. Basic Books.
[90] Reason, J. (1997). Managing the risks of organizational accidents. Ashgate.
[91] Rosenthal, C., Jones, N., Basiri, A., Hochstein, L., & Beyer, B. (2017). Managing the unexpected in distributed systems. Queue, 15(2), 1–28.
[92] Cukier, M., & Wang, H. (2020). Measuring and modeling resilience in computer systems. Reliability Engineering & System Safety, 193, 106660. DOI: https://doi.org/10.1016/j.ress.2019.106660
Downloads
Published
How to Cite
Issue
Section
License
Copyright (c) 2024 International Journal of Computational and Experimental Science and Engineering
This work is licensed under a Creative Commons Attribution 4.0 International License.
