See discussions, stats, and author profiles for this publication at: https://www.researchgate.

net/publication/369039197

Microservices Architecture

Research Proposal · March 2023

DOI: 10.13140/RG.2.2.21902.84802

CITATIONS READS

0 2,097

1 author:

Velibor Božić

554 PUBLICATIONS 92 CITATIONS

SEE PROFILE

All content following this page was uploaded by Velibor Božić on 07 March 2023.

The user has requested enhancement of the downloaded file.

 VELIBOR BOŽIĆ
Research proposal

Microservices Architecture
INTRODUCTION
Microservices architecture is a software development approach in which an application is
divided into small, independent services that can be developed, deployed, and scaled independently.
Each microservice performs a specific business function and communicates with other microservices
through well-defined APIs.
A well-defined API (Application Programming Interface) is a set of rules, protocols, and tools
that specify how different software components should interact with each other. An API provides a
standard way for different software components to communicate with each other, and defines the inputs,
outputs, and behaviors that are expected from each component.
In the context of microservices, a well-defined API is essential for ensuring that different
services can communicate with each other effectively and reliably. A well-defined API should include
clear specifications for the format of data that is exchanged between services, as well as rules for how
services should handle errors and exceptions. Additionally, a well-defined API should be designed to be
easy to use and maintain, with clear documentation and well-structured code.
Some key characteristics of a well-defined API include:
Clarity. A well-defined API should be clear and easy to understand, with concise and descriptive
documentation that outlines the purpose and behavior of each component.
Consistency. A well-defined API should be consistent across all components, with uniform data formats,
error handling, and behavior.
Stability. A well-defined API should be stable and reliable over time, with clear versioning and backward
compatibility to ensure that changes do not break existing integrations.
Security. A well-defined API should be designed with security in mind, with proper authentication,
access control, and data encryption measures in place.
A well-defined API is a critical component of any software system, and is particularly important
for microservices architecture, where effective communication between services is essential for
achieving the benefits of modularity, scalability, and flexibility.
 VELIBOR BOŽIĆ
Research proposal

BENEFITS AND DISADVANTAGES

Microservices architecture has become popular in recent years due to its flexibility, scalability,
and maintainability. Some of the benefits of microservices architecture include:

 Scalability
Microservices architecture allows applications to scale up or down quickly based on demand.
Developers can add or remove microservices as needed, without affecting the rest of the application.
 Resilience
Microservices are designed to be resilient to failures. If one microservice fails, it does not bring down the
entire application.
 Faster time-to-market
Microservices enable developers to work independently on small, focused services, which can be
developed and deployed more quickly than monolithic applications.
 Technology independence
Microservices architecture allows developers to choose the best technology for each microservice,
rather than being tied to a single technology stack.
 Easy maintenance
Microservices are typically easier to maintain than monolithic applications, as each microservice is
small and focused on a specific business function.
 Faster time-to-market
Microservices architecture enables developers to work independently on small, focused services, which
can result in faster development and deployment times.
However, there are also some challenges associated with microservices architecture.
Disadvantages of microservices architecture
 Complexity
Microservices architecture can be more complex to design and manage than traditional monolithic
architectures. This complexity can increase the risk of errors and make it more difficult to troubleshoot
issues.
 Distributed system management
Because microservices are distributed across different systems and technologies, it can be more
challenging to manage and monitor the entire system. This can make it more difficult to maintain overall
system performance and availability.
 Communication overhead
 VELIBOR BOŽIĆ
Research proposal

Microservices architecture relies heavily on inter-service communication, which can create additional
overhead and increase latency. This can be mitigated with careful API design and service discovery, but
it still remains a potential disadvantage.
 Higher development and maintenance costs
Developing and maintaining a microservices architecture can be more expensive than traditional
monolithic architectures, as it requires more specialized skills and tools. Additionally, each microservice
must be developed, tested, and deployed independently, which can increase development and
maintenance costs.
 Integration challenges
Integrating different microservices and ensuring they work seamlessly together can be challenging. It
can be difficult to ensure that all the different services are compatible and that changes to one service
do not break another service.
 Deployment complexity
Deploying microservices can be more complex than deploying a traditional monolithic application. Each
microservice must be deployed independently, and it can be more challenging to ensure that all services
are deployed correctly and working together as expected.

Microservices architecture requires careful consideration of trade-offs and trade-offs between

complexity and flexibility, and it may not be suitable for all use cases. It is important to weigh the
benefits and disadvantages of microservices architecture and assess whether it is the right approach for
a given project or organization.
RESULT OF MICROSERVCES ARCHITECTURE
The result of implementing a microservices architecture can be a more flexible, scalable, and
maintainable software system. By breaking down an application into small, independent services, each
service can be developed, deployed, and scaled independently. This can result in faster development
and deployment times, improved resilience and fault tolerance, and the ability to use a variety of
technology stacks.
DEVELOPING INTEGRATED INFORMATION SYSTEMS WITH MICROSERVICES –
YES OR NO
Microservices architecture can be appropriate for developing integrated information systems, as
it allows for the creation of independent services that can communicate with each other through well-
defined APIs. This can enable different parts of the system to be developed, deployed, and scaled
independently, while still allowing them to work together seamlessly.
 VELIBOR BOŽIĆ
Research proposal

For example, in an integrated information system that includes multiple components such as
data storage, user interface, and business logic, each of these components can be developed and
maintained as separate microservices. This can enable developers to work on each component
independently, using the most appropriate technology for the task at hand. The microservices can then
be integrated using APIs, enabling them to communicate and work together to create the integrated
information system.
However, it is important to note that implementing microservices architecture for an integrated
information system can also present some challenges. These challenges may include managing the
complexity of multiple services, ensuring consistency across services, and ensuring that the APIs
between services are well-defined and well-maintained. Additionally, there may be performance
implications if the APIs between services are not optimized for speed and efficiency.
Microservices architecture can be appropriate for developing integrated information systems,
but it is important to carefully consider the potential benefits and challenges of this approach before
deciding to implement it.
HOW MICROSERVICES COMMUNICATE AMONG THEMSELVES
Microservices communicate among themselves using well-defined APIs. There are several
ways in which microservices can communicate with each other, including:
 Synchronous communication. In synchronous communication, the calling service waits for a
response from the called service before continuing. This can be done using a RESTful API,
where the calling service sends an HTTP request to the called service, and the called service
responds with an HTTP response.
 Asynchronous communication. In asynchronous communication, the calling service sends a
message to the called service without waiting for a response. This can be done using a
message queue, where the calling service sends a message to a queue, and the called service
listens to the queue for incoming messages.
 Event-driven communication. In event-driven communication, the calling service publishes an
event to a message broker, and other services can subscribe to that event to be notified of
changes. This can be useful in situations where multiple services need to be notified of a
particular event, such as when a new user is created.
 Shared database. In some cases, microservices can communicate with each other by sharing a
database. However, this approach should be used with caution, as it can create dependencies
between services and make it difficult to maintain the independence and modularity of the
services.
 VELIBOR BOŽIĆ
Research proposal

It is important to note that when implementing microservices communication, it is essential to

ensure that the APIs between services are well-defined and well-maintained. This can help to ensure
consistency and reliability in the communication between services. Additionally, it is important to
consider the potential performance implications of different communication methods, and to optimize
communication to ensure that it is fast and efficient.
EXAMPLES OF INFORMATION SYSTEMS BASED ON MICROSERVICES
ARCHITECTURES
There are many real-world examples of information systems that are based on microservices
architecture.
 Netflix: Netflix is a popular video streaming service that has developed a microservices architecture
to handle its massive scale and complex requirements. The Netflix microservices architecture
consists of hundreds of independent microservices, each responsible for a specific function, such as
content management, user authentication, and video playback.
 Amazon: Amazon is a large e-commerce platform that uses microservices architecture to handle its
many different functions, including search, recommendations, and checkout. Amazon's
microservices architecture is based on a combination of Amazon Web Services (AWS) and custom-
built microservices.
 Uber: Uber is a ride-hailing service that uses microservices architecture to handle its various
functions, including ride matching, trip management, and payments. The Uber microservices
architecture is designed to be highly scalable and flexible, allowing the company to quickly adapt to
changing market conditions and user needs.
 Spotify: Spotify is a music streaming service that uses microservices architecture to manage its vast
catalog of music and provide personalized recommendations to users. The Spotify microservices
architecture is based on a combination of AWS and custom-built microservices, and is designed to
be highly scalable and reliable.
 Airbnb: Airbnb is a platform for booking vacation rentals that uses microservices architecture to
handle its various functions, including search, booking, and payment processing. The Airbnb
microservices architecture is based on a combination of AWS and custom-built microservices, and
is designed to be highly scalable and fault-tolerant.

Microservices architecture is a popular approach for building complex information systems that
can handle large volumes of data and traffic, while remaining flexible, scalable, and reliable. These real-
 VELIBOR BOŽIĆ
Research proposal

world examples demonstrate the effectiveness and versatility of microservices architecture in a variety
of different contexts.
USING MICROSERVICES ARCHITECTURES IN HOSPITAL
Microservices architecture can be used in hospitals and healthcare systems to build more
flexible and scalable information systems. Here are some potential benefits of using microservices
architecture in hospitals:
 Modular and scalable
Hospitals and healthcare systems can use microservices architecture to break down complex systems
into smaller, modular components. This can make it easier to scale up or down as needed, without
affecting other components.
 Flexibility
Microservices architecture can provide greater flexibility, allowing hospitals to quickly adapt to changing
needs and requirements. This can be especially useful in the healthcare industry, where regulations and
patient needs can change rapidly.
 Improved patient care
Microservices architecture can help hospitals and healthcare systems provide better patient care by
enabling more efficient and accurate data analysis. This can help doctors and other healthcare
professionals make more informed decisions and provide more personalized care.
 Integration
Microservices architecture can be used to integrate different systems and technologies, making it easier
to share data across different departments and healthcare providers. This can help improve
coordination and communication between different healthcare professionals.
 Fault tolerance
By using microservices architecture, hospitals can create redundant and fault-tolerant systems. This
can help ensure that critical healthcare systems remain available and functional, even in the event of
hardware or software failures.
Some specific examples of how microservices architecture can be used in hospitals include:
Electronic Health Record (EHR) systems. EHR systems can be built using microservices architecture,
allowing different modules to be developed and updated independently.
Patient portals. Patient portals can be built using microservices architecture, allowing patients to
access their health records, schedule appointments, and communicate with their healthcare providers.
 VELIBOR BOŽIĆ
Research proposal

Medical imaging systems. Medical imaging systems can be built using microservices architecture,
allowing doctors and other healthcare professionals to store, share, and analyze medical images more
efficiently.
Microservices architecture can be a valuable tool for hospitals and healthcare systems looking
to build more flexible, scalable, and reliable information systems.
PRECONDITIONS FOR PROVIDE MICROSERVICES ARCHITECTURE
To provide microservices architecture, there are several preconditions that need to be met.
These include:
Organizational culture. Microservices architecture requires a shift in organizational culture to prioritize
communication and collaboration between teams. This means that teams must be willing to work closely
together, share information, and embrace a culture of continuous improvement.
DevOps practices. To effectively provide microservices architecture, it is important to adopt DevOps
practices such as continuous integration and delivery, automated testing, and infrastructure automation.
This helps ensure that microservices can be developed, tested, and deployed quickly and reliably.
Containerization and orchestration. Microservices architecture is often implemented using
containerization and orchestration tools such as Docker and Kubernetes. This allows microservices to
be deployed and managed more efficiently, while also ensuring that they can scale up or down as
needed.
API design. A well-designed API is essential for microservices architecture, as it provides a standard
way for microservices to communicate with each other. APIs should be well-documented, versioned,
and follow industry standards.
Monitoring and logging. To effectively provide microservices architecture, it is important to have robust
monitoring and logging systems in place. This allows teams to identify and troubleshoot issues quickly,
while also ensuring that microservices are performing optimally.
Providing microservices architecture requires a combination of technical expertise,
organizational culture, and DevOps practices. By meeting these preconditions, organizations can build
more flexible, scalable, and reliable information systems that can better meet the needs of their users.
RISKS IN USING MICROSERVICES
There are several risks associated with using microservices architecture, including:
 Complexity
As mentioned earlier, microservices architecture can be more complex than traditional monolithic
architectures. This can make it more difficult to design, develop, and maintain a microservices-based
system. It can also make it more challenging to troubleshoot issues.
 VELIBOR BOŽIĆ
Research proposal

 Inter-service communication
Microservices rely heavily on inter-service communication, which can be a source of risk. If
communication between services breaks down, it can cause the entire system to fail. Additionally, there
is the risk of increased latency and communication overhead.
 Data consistency
When data is distributed across multiple microservices, it can be challenging to ensure data
consistency across the entire system. This can lead to data inconsistencies and data integrity issues.
 Security
Microservices architecture can introduce security risks, particularly if services are not properly secured.
Since each microservice is a separate application, it can be more challenging to secure the entire
system. Additionally, the increased complexity of microservices architecture can make it more difficult to
identify and mitigate security vulnerabilities.
 Vendor lock-in
If an organization relies heavily on third-party microservices, it can become locked into those vendors.
This can limit the organization's flexibility and make it more difficult to switch to different vendors in the
future.
 Operational complexity
As a microservices-based system grows in size, it can become more difficult to manage and monitor.
This can increase operational complexity and require more resources to manage.

Microservices architecture introduces new risks that must be carefully managed. Organizations
should weigh the benefits and risks of microservices architecture and assess whether it is the right
approach for their needs. Additionally, organizations should put in place measures to mitigate risks
associated with microservices architecture.
MITIGATING THE RISKS
There are several strategies for mitigating the risks associated with microservices architecture,
including:
Service design. Careful service design can help mitigate the risks associated with microservices
architecture. This includes designing services to be loosely coupled, with clear interfaces and well-
defined boundaries. It is also important to design services to be fault-tolerant and resilient.
Service testing. Rigorous testing can help identify and mitigate risks associated with microservices
architecture. This includes testing each service independently, as well as testing the entire system as a
whole. It is important to test for scalability, fault tolerance, and compatibility.
 VELIBOR BOŽIĆ
Research proposal

Service monitoring. Monitoring each service can help identify issues before they become serious
problems. This includes monitoring performance, uptime, and usage patterns. It is also important to
monitor inter-service communication and data consistency.
Service security. Implementing robust security measures can help mitigate security risks associated with
microservices architecture. This includes securing each service individually, as well as securing the
entire system. It is important to implement security best practices, such as access controls, encryption,
and authentication.
Service governance. Establishing governance processes can help mitigate risks associated with
microservices architecture. This includes establishing standards for service design and development, as
well as establishing processes for service deployment and management. It is also important to establish
processes for versioning, configuration management, and change management.
Service documentation. Documentation can help mitigate risks associated with microservices
architecture. This includes documenting each service's interface, behavior, and dependencies. It is also
important to document the overall system architecture and any dependencies between services.
Mitigating the risks associated with microservices architecture requires a combination of
technical and organizational measures. Organizations must carefully design, test, and monitor their
services, as well as implement robust security and governance measures. Additionally, organizations
must establish clear documentation and communication processes to ensure that all stakeholders are
aware of the risks and how they are being managed.
CONCLUSION
Microservices architecture is a popular approach for building complex and scalable information
systems. It allows organizations to develop and deploy services independently, with clear boundaries
and interfaces. This can lead to increased agility, flexibility, and resilience.

However, microservices architecture also introduces new risks and challenges, such as
increased complexity, inter-service communication issues, data consistency problems, security risks,
vendor lock-in, and operational complexity. Organizations must carefully weigh the benefits and risks of
microservices architecture and put in place measures to mitigate the risks.
Further exploration of microservices architecture can include learning about the best practices
for designing, developing, testing, deploying, and managing microservices-based systems. It can also
involve exploring the latest tools and technologies for microservices, such as containerization, service
meshes, and serverless architectures. Additionally, it can involve studying real-world examples of
microservices-based systems in various industries, such as healthcare, finance, e-commerce, and
social media.
 VELIBOR BOŽIĆ
Research proposal

REFERENCES
Fowler, M. (2014). Microservices: a definition of this new architectural term. Retrieved from
https://martinfowler.com/articles/microservices.html

Newman, S. (2015). Building microservices: Designing fine-grained systems. O'Reilly Media, Inc.

Balalaie, A., Heydarnoori, A., & Jamshidi, P. (2016). Microservices architecture enables devops:
Migration to a cloud-native architecture. IEEE Software, 33(3), 42-52.

Zhu, L., & Zhang, J. (2017). Microservices: A survey on self-healing techniques. IEEE Transactions on
Services Computing, 10(5), 704-716.

Dragoni, N., Dustdar, S., & Martens, A. (2017). Microservices: yesterday, today, and tomorrow.
Communications of the ACM, 60(6), 78-87.

Lewis, J., & Fowler, M. (2018). Microservices. Retrieved from https://microservices.io/

Pahl, C. (2018). Containerization and the PaaS cloud: A case study of microservices-based software
deployment. Future Generation Computer Systems, 79, 691-702.

Tilkov, S. (2018). The evolution of microservices at SoundCloud. IEEE Software, 35(3), 72-77.

Varga, A., & Farkas, R. (2018). The impact of microservices on software quality. Journal of Software:
Evolution and Process, 30(1), e1930.
Datta, S. K., & Roychoudhury, S. (2019). An empirical study of service composition in microservices-
based software systems. Empirical Software Engineering, 24(1), 44-82.

Xu, J., & Yu, Y. (2019). Microservices testing: Challenges and opportunities. IEEE Software, 36(4), 80-
86.

Oktavianus, Y., & Mäenpää, T. (2019). A systematic review of challenges and solutions for
microservices architecture. Journal of Systems and Software, 152, 162-183.
 VELIBOR BOŽIĆ
Research proposal

Cervantes, H., Ramos, J. L., & Arias, M. (2020). Performance evaluation of container orchestrators for
microservices-based applications. IEEE Access, 8, 23523-23534.

Zhao, X., Zeng, L., Li, J., Li, X., & Li, X. (2020). Understanding microservices through microservice
architecture patterns: A systematic literature review. Journal of Systems and Software, 169, 110617.

Viera, M., Caiado, M., & Sampaio, A. (2020). Microservices architecture for web applications: A
systematic review. Journal of Systems and Software, 167, 110594.

Nourbakhsh, M., & Hosseini, M. J. (2020). A survey on microservices for internet of things: Architecture,
implementation, deployment, and challenges. Journal of Network and Computer Applications, 154,
102612.

Tavares, E., Pinto, L. S., Carvalho, T., & Antunes, N. (2021). A systematic review of microservices
testing approaches. Information and Software Technology, 131, 106418.

Kazhamiakin, R., & Männistö, T. (2021). A survey of testing challenges and solutions in microservices.
Journal of Systems and Software, 171, 110897.

Kugler, K., Hohenstein, U., & Hasselbring, W. (2021). Dynamic microservices architecture using
function-as-a-service. Future Generation Computer Systems, 117, 181-193.

Polli, R., & Di Francesco Maesa, D. (2021). Microservices-based architectures for edge and fog
computing: A survey. Future Generation Computer Systems, 120, 503-527.
Zou, Y., Liu, J., Zhang, H., & Li, S. (2021). Microservice architecture and its application in industrial big
data analytics. Computers in Industry, 124, 103408.

Medeiros, R. F., da Silva, D. S., & Araujo, J. E. (2021). Architectural and operational aspects of
microservices: A systematic literature review. Journal of Systems and Software, 176, 110938.

Lee, H., Kim, D., & Moon, J. (2021). Microservices-based architecture for IoT application in smart cities.
Journal of Network and Computer Applications, 182, 102973.
 VELIBOR BOŽIĆ
Research proposal

Tran, H. N., Tran, M. T., & Vu, T. H. (2021). Microservices architecture: Current state, challenges and
future directions. Future Generation Computer Systems, 116, 219-234.

Li, J., Zhang, Y., & Zhao, X. (2021). QoS-aware microservices selection using machine learning for
cloud computing. Journal of Systems and Software, 177, 110956.

Pang, Z., Tang, C., & Li, Y. (2021). Microservices-based architecture for intelligent manufacturing:
Review, challenges and future directions. Journal of Intelligent Manufacturing, 32(5), 1095-1114.

Jiang, J., & Wang, Z. (2021). Microservices for cloud-native computing. Journal of Network and
Computer Applications, 184, 103064.

Safayeni, F., Almeida, R. L., & Rashidi, T. H. (2021). Evolution of microservices: State-of-the-art and
future directions. Journal of Systems and Software, 181, 110913.

Hafeez, M. A., & Rathore, M. M. (2021). Microservices-based software development methodology: A

systematic literature review. Journal of Systems and Software, 173, 110871.

Wang, L., Dong, H., Liu, Y., & Yin, Y. (2021). Microservices-oriented software engineering: A systematic
review. Journal of Systems and Software, 179, 110936.

Zou, L., Fang, Z., Zhu, Y., & Huang, C. (2022). Microservices-based design for large-scale geospatial
information systems. ISPRS International Journal of Geo-Information, 11(1), 6.

Mohammadi, M., Lohi, M., & Ghafari, S. (2022). A comprehensive review on microservices security:
Threats, solutions, and open issues. Computers & Security, 106, 102538

View publication stats