FEATURES OF DESIGNING SOFTWARE DISTRIBUTED SYSTEMS ARCHITECTURE

Ivan Rovetskii

Abstract


Background. A pressing problem in designing distributed software systems is that they must operate stably under high load conditions when thousands of users want to receive certain resources provided by system services. To ensure high availability and stability of highly loaded software services, they are deployed in managed multiprocessor distributed systems (clusters). These kinds of resources have a high value, so in practice, various cloud platforms (Google Cloud, Amazon, Azure, etc.) are most often used, which provide these resources, charging only for the time of direct use of them. Services must be able to fully utilize the provided resources during data processing, so they must be designed using special architectural solutions. Therefore, the purpose of this research is to theoretically investigate the architectural solution features when designing software services of distributed systems.

Materials and Methods. The paper presents a theoretical research design of features of distributed software systems architecture which is based on the analysis and comparison of facts obtained from scientific sources and the author's practical experience as well.

Results and Discussion. The article shows that Kubernetes is one of the main software solutions designed for deploying software applications in parallel distributed systems. It was established that microservice architecture is the optimal architectural solution for designing software services of distributed systems, given the specifics of deploying software systems under Kubernetes management.

Conclusion. A multithreaded design must be used for effective scaling distributed software system under high load. However, performance improvement occurs only if the parallel algorithm uses parallel rather than concurrent multithreading mode. The concurrent mode of thread operation is advisable to use only in the case of blocking operations when some threads are in a waiting mode. Synchronous architecture has a good performance, but there are limitations associated with blocking threads until the results of client requests are received. The asynchronous model allows for a larger number of requests than the synchronous one but requires a fully asynchronous API when working with external services, and is also more difficult to debug the service and fix errors.

Keywords: distributed systems, clusters, cloud platforms, microservices, microservice architecture, multithreading.


Full Text:

PDF

References


  1. Burns, B. (2025). Designing Distributed Systems: Patterns and Paradigms for Scalable, Reliable Systems Using Kubernetes: O’Reilly. https://www.oreilly.com/library/view/designing-distributed-systems/9781098156343/
  2. Adkins, H., Beyer, B., Blankinship, P., Lewandowski, P., Oprea, A., Stubblefield, A. (2020). Building Secure and Reliable Systems: Best Practices for Designing, Implementing, and Maintaining Systems: O’reilly. https://www.oreilly.com/library/view/building-secure-and/9781492083115/
  3. Gorton, I. (2022). Foundations of Scalable Systems: Designing Distributed Architectures 1st Edition: O'Reilly. https://www.oreilly.com/library/view/foundations-of-scalable/9781098106058/
  4. Tanenbaum, A. S., Steen, M. (2006). Distributed Systems: Principles and Paradigms: Pearson. https://pdf-up.com/download/distributed-systems-principles-and-paradigms-andrew-s-tanenbaum-4951969
  5. Vitillo, R. (2021). Understanding Distributed Systems: What every developer should know about large distributed applications. https://cdn.bookey.app/files/pdf/book/en/understanding-distributed-systems.pdf
  6. Herlihy, M., Shavit, N. (2012). The Art of Programming Multiprocessor: Elsevier. https://www.educate.elsevier.com/book/details/9780123973375
  7. Sosinsky, B. (2011). Cloud Computing Bible: Wiley Publishing. DOI: 10.1002/9781118255674
  8. Buyya, R., Broberg, J., Goscinski, A.M. (2011). Cloud Computing: Principles and Paradigms: Wiley Publishing. DOI:10.1002/9780470940105
  9. Luksa, M. (2023). Kubernetes in Action: Manning. https://www.scribd.com/ document/659803971/Kubernetes-in-Action-Second-Edition-MEAP-V15
  10. Boorshtein, M., Surovich, S. (2024). Kubernetes – An Enterprise Guide: Master containerized application deployments, integrate enterprise systems, and achieve scalability: Packt Publishing. https://www.packtpub.com/en-SK/product/kubernetes-an-enterprise-guide-9781835081754?srsltid=AfmBOor_Cra9iEVmhmtw_DirzU_mzs3KGN4Cfqff4tglkvTX6Zf9dHBk
  11. Nickoloff, J, Kuenzli, S. (2019). Docker in Action: Manning. https://www.manning.com/books/docker-in-action-second-edition
  12. Poulton, N. (2023). Docker Deep Dive: Packt Publishing. https://cdn.bookey.app/files/pdf/book/en/docker-deep-dive.pdf
  13. Newman, S. (2015). Building Microservices: Designing Fine-Grained Systems: O'Reilly. https://www.oreilly.com/library/view/building-microservices/9781491950340/
  14. Bruce, M., Pereira, P.A. (2019). Microservices in Action: Manning. https://www.oreilly.com/library/view/microservices-in-action/9781617294457/
  15. Fowler, S. J. (2016). Production-Ready Microservices: Building Standardized Systems Across Engineering an Organization: O'Reilly. https://www.oreilly.com/library/view/production-ready-microservices/9781491965962/
  16. Biehl, M. (2016). RESTful API Design: Createspace Independent Publishing Platform. https://books.google.com.ua/books?id=DYC3DwAAQBAJ&printsec= frontcover&hl=uk&source=gbs_ge_summary_r&cad=0#v=onepage&q&f=false
  17. Varanasi, B., Bartkov, M. (2022). Spring REST. Building Java Microservices and Cloud Applications: Apress. https://www.oreilly.com/library/view/spring-rest-building/9781484274774/
  18. Amundsen, M. (2022). RESTful Web API Patterns and Practices Cookbook: Connecting and Orchestrating Microservices and Distributed Data: O’Reilly. https://www.oreilly.com/library/view/restful-web-api/9781098106737/
  19. Bellemare, A. (2023). Building an Event-Driven Data Mesh: Patterns for Designing & Building Event-Driven Architecture s: O’Reilly. https://www.oreilly.com/library/view/building-an-event-driven/9781098127596/
  20. Narkhede, N., Shapira, G., Palino, T. (2017). Kafka: The Definitive Guide: Real-Time Data and Stream Processing at Scale: O'Reilly. https://www.oreilly.com/library/view/kafka-the-definitive/9781491936153/
  21. Videla, A., Williams, J.J.W. (2012). RabbitMQ in Action Distributed Messaging for Everyone: Manning. https://classpages.cselabs.umn.edu/Spring-2018/csci8980/Papers/PublishSubscribe/RabbitMQinAction.pdf
  22. Richards, M., Monson-Haefel, R., (2009). Chappell D. A. Java Message Service: O'Reilly. https://www.oreilly.com/library/view/java-message-service/9780596802264/
  23. Fowler, M. (2003). Patterns of Enterprise Application Architecture: Longman (Pearson Education). https://ptgmedia.pearsoncmg.com/images/9780321127426/samplepages/0321127420.pdf
  24. Joshi, U. (2023). Patterns of Distributed Systems: Addison-Wesley Professional. https://www.oreilly.com/library/view/patterns-of-distributed/9780138222246/
  25. Goetz, B. Bloch, J., Peierls, T., Bowbeer, J., Holmes, D., Lea, D. (2006). Java Concurrency in Practice: Longman (Pearson Education). https://ptgmedia. pearsoncmg.com/images/9780321349606/samplepages/9780321349606.pdf
  26. Leszko, R. (2017). Continuous Delivery with Docker and Jenkins: Packt Publishing. https://www.packtpub.com/en-us/product/continuous-delivery-with-docker-and-jenkins-3rd-edition-9781803237480
  27. Kaufmann, M., Bos, R., Vries, M. (2024). GitHub Actions in Action Continuous integration and delivery for DevOps: Manning. https://www.oreilly.com/library/view/github-actions-in/9781633437302/
  28. Chhajed, S. (2015). Learning ELK Stack: Packt Publishing https://www.packtpub.com/en-ch/product/learning-elk-stack-9781785887154




DOI: http://dx.doi.org/10.30970/eli.31.4

Refbacks

  • There are currently no refbacks.