The American Journal of Engineering and Technology
123
https://www.theamericanjournals.com/index.php/tajet
TYPE
Original Research
PAGE NO.
123-132
10.37547/tajet/Volume07Issue05-10
OPEN ACCESS
SUBMITED
24 March 2025
ACCEPTED
20 April 2025
PUBLISHED
15 May 2025
VOLUME
Vol.07 Issue 05 2025
CITATION
Artem Iurchenko. (2025). Optimization of Microservices Architecture
Performance in High-Load Systems. The American Journal of Engineering
and Technology, 7(05), 123
–
132.
https://doi.org/10.37547/tajet/Volume07Issue05-10
COPYRIGHT
© 2025 Original content from this work may be used under the terms
of the creative commons attributes 4.0 License.
Optimization of
Microservices Architecture
Performance in High-Load
Systems
Artem Iurchenko
Senior Software Engineer at Dexian Atlanta, USA
Abstract:
The article addresses the issue of optimizing
the performance of microservices architecture under
high-load conditions. Based on a systematic literature
review, six key quality attributes of microservices are
identified:
scalability,
performance,
availability,
manageability,
security,
and
testability.
A
comprehensive
approach
to
optimizing
the
performance of microservices architecture in high-load
systems is examined, incorporating containerization
(Docker), orchestration (Kubernetes), architectural
patterns (CQRS, Event Sourcing), caching (Redis), and
fault tolerance mechanisms (Circuit Breaker, Bulkhead).
The study on load testing conducted on a prototype e-
commerce system confirmed the effectiveness of the
combined application of these solutions: the average
response time with 5,000 concurrent users was
reduced to 450
–
500 ms, while the error rate did not
exceed 0.5%. The topic of optimizing the performance
of microservices architecture in high-load systems is of
interest to researchers, system architects, and
engineers in distributed computing systems, as the
application of modern load balancing methods,
resource
orchestration,
and
inter-service
communication optimization based on contemporary
parallel computing models enables a new level of
scalability, fault tolerance, and adaptability of
information infrastructures. This is critically important
for the stable operation of complex distributed systems
under constantly increasing demands for processing
and analyzing large volumes of data.
Keywords:
microservices
architecture,
high-load
systems,
performance
optimization,
Docker,
Kubernetes, CQRS, Event Sourcing, caching, fault
The American Journal of Engineering and Technology
124
https://www.theamericanjournals.com/index.php/tajet
tolerance.
Introduction:
Modern
web
applications
are
experiencing rapid growth in audience size and the
volume of processed data, which places significant
strain on their infrastructure. Traditional monolithic
systems often prove inefficient under peak loads and
present challenges in terms of scalability and updates.
In response to these challenges, the microservices
architecture
(MSA)
emerged,
enabling
the
decomposition of an application into a set of
independent services, each performing a specific
function [5]. This approach allows for fine-tuned
performance optimization and flexible scalability,
which is particularly crucial in high-load systems [6].
However, alongside its clear advantages, the
microservices model raises concerns regarding data
consistency, distributed monitoring, and fault
tolerance. Therefore, performance optimization in the
context of microservices architectures remains a highly
relevant issue [4].
Bass L., Clements P., and Kazman R. [1], in their
publication Software Architecture in Practice, provide a
detailed discussion of fundamental principles such as
modularity, scalability, and reliability, which form the
foundation for building resilient systems. Similarly,
Lewis J. and Fowler M. [3] define microservices
architecture,
emphasizing
the
capability
for
independent
deployment
and
evolution
of
components
—
an aspect critical for performance
enhancement under high-load conditions. Newman S.
[5] expands on these ideas, focusing on the practical
aspects of functional decomposition and the
integration of modern tooling to ensure fault tolerance
and system flexibility.
Belnar A. [2] proposes an approach based on event-
driven architecture, which facilitates the efficient
processing
of
large
data
volumes
through
asynchronous communication between services. The
study by Shumilov M. I. [6] focuses on optimizing high-
load web projects using microservices architecture,
proposing a comprehensive methodology for load
balancing and inter-service interaction optimization,
thereby improving overall system efficiency.
Li S. et al. [4] conduct a systematic literature review,
analyzing
existing
approaches
to
evaluating
microservices architecture quality, which helps identify
gaps in the integration of theoretical models and
practical implementations. Zhang H. and Babar M. A.
[7], in an empirical study, highlight methodological gaps
in conducting systematic reviews in software
engineering, proposing a unified framework for
assessing the effectiveness of various architectural
solutions.
The article by Torkura K. A. et al. [8] explores the
application of chaos engineering to identify
vulnerabilities and enhance the fault tolerance of cloud
infrastructures through targeted failure and attack
simulations. The authors propose an integrated
methodology that allows for the evaluation and
improvement of cloud service security by identifying
critical points and developing effective strategies for
mitigating potential threats.
Despite the increasing adoption of microservices
solutions in industry and the examination of specific
optimization aspects in literature, a comprehensive
approach to performance improvement remains
underexplored. In particular, there is no clear
understanding of the interrelations between various
optimization
techniques
(containerization,
load
balancing, caching, etc.), nor are there unified metrics
for
quantitatively
assessing
the
achieved
improvements across different domains. The absence
of such holistic models results in decision-making being
conducted in an ad hoc manner, without systematically
considering trade-offs between performance and other
quality attributes.
The objective of this study is to develop and consolidate
approaches for optimizing the performance of
microservices architecture under high-load conditions,
leveraging existing quality improvement techniques
while also proposing a methodological framework for
comprehensive evaluation and comparison of applied
tools.
The scientific novelty of this research lies in the
formation of an integrated optimization model that
combines several key directions:
•
Selecting the optimal containerization and
orchestration approach
The American Journal of Engineering and Technology
125
https://www.theamericanjournals.com/index.php/tajet
•
Correctly implementing architectural patterns
(Event-driven, CQRS, Event Sourcing)
•
Analyzing and comparing monitoring and scaling
strategies to enhance performance metrics
This model is designed to assist researchers and
practitioners in making systematic optimization
decisions and evaluating the achieved outcomes.
The proposed hypothesis suggests that the coordinated
use of orchestration tools (Docker, Kubernetes) in
conjunction with architectural patterns (CQRS, Event
Sourcing) will yield higher performance levels in
microservices systems compared to the isolated
implementation of individual solutions.
To validate the hypothesis and achieve the research
objective, a systematic literature review was conducted
to identify key optimization directions and summarize
empirical findings.
RESEARCH RESULTS
The development of microservices architecture is
closely linked to the search for ways to enhance the
flexibility and speed of application development [1].
Initially, the concepts of small-scale services were
associated with the idea of service-oriented
architectures (SOA), where interaction between
components was conducted through standardized
protocols such as SOAP [7]. However, classical SOA in
many cases exhibited a high degree of component
interdependence, as well as extensive "bus-oriented"
solutions (Enterprise Service Bus), which led to
increased complexity and slowed down development
processes.
Microservices, as a logical continuation of the
"ideological branch" of SOA, are distinguished by
several key characteristics [5]:
1.
Independence and autonomy. Each service
operates as a standalone application with its own
lifecycle and database (if necessary). This simplifies
deployment and updates while increasing isolation
in case of failures [6].
2.
Focus on business functionality. Microservices are
structured around specific business tasks, reducing
cognitive load on developers and improving
domain understanding.
3.
Lightweight interaction. Communication between
services is often implemented through lightweight
protocols (Representational State Transfer (REST),
Google Remote Procedure Calling (gRPC), event-
driven
communication),
which
simplifies
integration and system expansion [4, 7].
4.
Infrastructure automation. DevOps practices,
containerization (Docker), and orchestration
(Kubernetes) are integral to the microservices
philosophy, ensuring rapid scaling and continuous
delivery.
Thus, the emergence of microservices was a response
to the challenges of the tight coupling of monolithic
applications and the cumbersome infrastructure of
classical SOA while introducing new challenges related
to quality assurance. For a systematic understanding of
the differences between monolithic, classical SOA, and
microservices-based systems, a comparative analysis
based on key characteristics is presented in Table 1.
Table 1. Differences between monolithic, classical SOA, and microservices systems [4-7].
Criterion
Monolithic
Architecture
Service-Oriented
Architecture (SOA)
Microservices
Architecture
(MSA)
Structure
Single application,
all modules are
bundled into one
deployable unit
A set of services often
connected via an ESB
(Enterprise Service Bus)
A set of autonomous services,
each with its own database
and lifecycle
Scalability
Vertical: increasing
Hybrid:
in
theory,
Horizontal: each service scales
The American Journal of Engineering and Technology
126
https://www.theamericanjournals.com/index.php/tajet
Criterion
Monolithic
Architecture
Service-Oriented
Architecture (SOA)
Microservices
Architecture
(MSA)
resources for the
entire application
individual services can be
scaled, but this is often
difficult
independently,
improving
flexibility and reliability
Deployment
Monolithic:
changes
require
recompilation and
redeployment
of
the
entire
application
Partially distributed, but
ESB
integration
often
complicates support for
new services
Automated,
often
containerized (Docker) and
orchestrated
(Kubernetes);
each service is deployed
independently
Dependencies
High
interdependency
between modules
within
a
single
codebase
Moderate
interdependency, services
communicate through a
shared protocol but often
depend on a central ESB
Low
interdependency,
interaction via lightweight
APIs or events, minimal
infrastructure dependencies
Updating and
Modification
Difficult to localize
changes, test, and
release patches
Partially localized, but the
ESB
can
become
a
bottleneck
Changes are localized at the
service
level
(DevOps
approach), allowing for rapid
updates and independent
releases
Fault
Tolerance
Failure
in
one
module can disrupt
the entire system
Failure of a single service
may block the entire
business process within
the ESB
Service autonomy; failure of
one service does not crash the
entire system. Circuit Breaker
patterns and event retries are
applied
Example
Traditional
enterprise
applications (ERP,
CRM)
Large-scale systems with
ESB (many government
and fintech solutions)
Netflix, Amazon, eBay, certain
components of PayPal, Twitter
The comparative characteristics of microservices
systems presented in Table 1 highlight the fundamental
differences in module interaction, deployment, and
scalability, which directly impact performance,
manageability, and testability.
In the context of microservices, six core quality
attributes quality assurance (QA) are identified, as
illustrated in Figure 1
The American Journal of Engineering and Technology
127
https://www.theamericanjournals.com/index.php/tajet
Fig. 1. Core quality attributes in the microservices context
1.
Scalability is one of the most recognized reasons for
adopting MSA, as the ability to horizontally scale
individual services enables resource efficiency and
resilience to peak loads. However, scalability is
closely interconnected with other QA attributes.
For instance, attempts to increase throughput by
adding more service replicas may negatively impact
data consistency.
2.
Performance is critical for high-load systems,
where low latency and high throughput are
essential. However, the distributed nature of MSA
(network
calls,
serialization/deserialization,
coordination) often results in increased overhead
costs [6]. This necessitates careful optimization of
interaction layers (API Gateways, encryption,
communication protocols) and the application of
caching mechanisms.
3.
Availability is generally easier to ensure in
microservices architecture due to service isolation.
However, a major challenge is the "cascading
failure effect." To mitigate this, patterns such as
Circuit Breaker and Bulkhead (Netflix OSS, Hystrix)
and replication mechanisms are employed [5].
4.
Observability/Manageability
poses
significant
challenges as each service operates as a separate
process, making centralized metric and log
collection a complex task (Li et al., 2020). Tool
stacks such as ELK (Elasticsearch, Logstash, Kibana)
or Prometheus/Grafana facilitate the visualization
of key metrics (latency, CPU, memory usage) and
help identify bottlenecks.
5.
Security in distributed systems complicates
authentication and authorization while increasing
the risk of data leaks during inter-service
communication. Modern approaches such as
OAuth 2.0, JWT, and Mutual TLS provide
mechanisms for API protection and access control
tailored to microservices architecture [1].
6.
Testability becomes a greater concern in MSA, as
the number of interaction points and integration
scenarios increases significantly. Containerization,
service stubs, and contract testing mechanisms
(Consumer-Driven Contracts) aim to simplify this
process [7].
These six attributes form a conceptual "matrix" of
considerations for architects and developers. When
The American Journal of Engineering and Technology
128
https://www.theamericanjournals.com/index.php/tajet
designing a specific system, it is crucial to consciously
prioritize each QA and maintain a balance among them
[4].
Thus, microservices architecture differs significantly
from monolithic and classical SOA approaches in terms
of component independence, deployment methods,
and scalability. The six identified quality attributes
(scalability, performance, availability, observability,
security, and testability) serve as a fundamental
framework for analyzing and optimizing MSA. The
following sections will explore specific practices and
tools for achieving an optimal balance among these
attributes, along with experimental results evaluating
performance in real high-load scenarios.
Methods and tools for performance optimization in
high-load microservices systems
In the context of microservices architecture (MSA), a
wide range of approaches exist for optimizing
performance. These include engineering tools such as
Docker and Kubernetes, architectural patterns like
Command and Query Responsibility Segregation
(CQRS) and Event Sourcing, as well as monitoring and
testing methodologies. Researchers highlight the most
common and effective solutions in this area.
Chaos Engineering is a methodology for testing the
fault tolerance of distributed systems, particularly
within microservices architecture. The introduction of
tools such as Gremlin and Chaos Monkey allows for an
assessment of system behavior in the event of
unexpected failures. This method involves the
deliberate introduction of controlled incidents, ranging
from artificial service outages to simulated network
latency, to uncover hidden vulnerabilities and evaluate
the system’s ability to self
-recover. The goal of chaos
engineering is to create a safe and controlled
environment where engineers can model various
failure scenarios, including network disruptions, server
failures, or sudden traffic spikes. By identifying
weaknesses and failure points, chaos engineering
enables
targeted
improvements,
architectural
redesigns, or the implementation of corrective
measures to enhance system resilience. This helps
organizations develop robust systems capable of
handling failures and unforeseen events with minimal
impact on users and customers [8].
Containerization is one of the key tools for optimizing
the performance of microservices applications. Docker
enables each service to be deployed in an isolated
environment with all its dependencies, ensuring faster
deployment due to pre-built images containing the
necessary runtime environment, increased portability
by providing developers with a consistent environment
across different servers, and efficient resource
utilization since containers consume less memory than
virtual machines and start up more quickly [5, 6].
However, high container density on a single node can
negatively impact performance if CPU and memory
limits are not properly configured [1]. Additionally,
every network call between containers, even within the
same host, introduces latency, which must be
considered when designing high-load systems.
To manage a large number of containers and services in
a scalable environment, orchestration systems such as
Kubernetes (K8s), Docker Swarm, and OpenShift are
widely used [6]. Kubernetes provides autoscaling
(Horizontal Pod Autoscaler), which increases the
number of service instances as the load grows; service
discovery and load balancing mechanisms (Service,
Ingress), which simplify request routing; resource
management (Requests & Limits for CPU and memory)
to minimize resource contention between containers;
and flexible deployment configurations (Deployment,
StatefulSet), reducing downtime during service
updates.
According to Newman [5], implementing DevOps
practices such as Continuous Integration/Continuous
Delivery CI/CD and Infrastructure as Code, combined
with orchestration, significantly improves the efficiency
of release management processes. From a system
performance
perspective,
a
well-configured
Kubernetes cluster enables automatic load balancing
and rapid recovery of failed services [6].
Under high-load conditions and a large number of
interactions between microservices, the classic REST-
oriented model can become a bottleneck [4]. The
event-driven approach (EDA) relies on message brokers
(Kafka, RabbitMQ), allowing services to publish and
subscribe to events [7].
CQRS separates read (Query) and write (Command)
operations, enabling optimization for specific
The American Journal of Engineering and Technology
129
https://www.theamericanjournals.com/index.php/tajet
requirements. In high-load systems, this allows for
storing data in different structures (e.g., Structured
Query Language (SQL) for commands and NoSQL for
queries), thereby accelerating read operations [6], and
reducing database resource contention by processing
update and read operations through separate services
[5].
Event Sourcing, instead of storing a "snapshot" of the
current state, records all events (such as orders or
transactions) that modified the state [4]. This approach
simplifies the replay of historical changes, providing
advantages in analytics and data recovery while
enhancing scalability since services can process
incoming events independently without blocking the
main database (Shumilov, 2024).
To
reduce
latency,
caching
systems
(Redis,
Memcached) are commonly used. This is particularly
relevant in microservices architecture, where
numerous identical requests can overwhelm a single
service. Load balancing (via Nginx, HAProxy, or
Kubernetes Ingress) helps distribute incoming requests
evenly and quickly reroute traffic in case of node failure
[1].
In microservices architecture, each service must
withstand a certain volume of requests during peak
moments [4]. Tools such as JMeter, Gatling, or Locust
enable testing of how the system responds to
predefined scenarios [6]. It is essential to conduct not
only load testing but also stress testing to determine
failure points and predefine reserves for autoscaling
[5].
The transition to microservices generates a high
volume of inter-service requests, making it difficult to
identify bottlenecks [1]. Recommended solutions for
diagnosing latency and failures include tracing systems
(Jaeger, Zipkin), which visualize the complete request
path, and monitoring stacks (Prometheus + Grafana,
ELK), which collect CPU, memory, network activity, and
log metrics [4].
With a large number of microservices, traditional
integration testing becomes resource-intensive. The
CDC (Consumer-Driven Contracts) approach focuses on
agreements between the service "provider" and the
"consumer," enabling interface correctness verification
without launching the entire system [6].
OpenTelemetry is a tool for comprehensive monitoring
of distributed applications. This open-source platform
provides a unified standard for collecting, processing,
and exporting metrics, traces, and logs, enabling
performance analysis and identifying architectural
bottlenecks. Due to its modular architecture and
flexible integration with various observability systems,
OpenTelemetry standardizes data collection, which is
crucial for optimizing complex distributed systems.
Datadog, a cloud-based monitoring and analytics
platform, demonstrates high efficiency under heavy
loads due to its ability to consolidate various data
sources into a unified information space. Leveraging
modern correlation analysis algorithms and machine
learning, Datadog enables proactive anomaly detection
and infrastructure issue forecasting in microservices
environments.
Its
integration
with
container
orchestrators such as Kubernetes, along with support
for plugins and APIs, facilitates rapid scaling and
adaptation to load changes, which is critical for
maintaining fault tolerance and system stability.
New Relic, with its comprehensive observability tools,
allows for detailed performance analysis across all
layers of the application stack. The platform integrates
transaction data, performance metrics, and traces,
providing a holistic view of microservices architecture
operation. The use of a flexible query language (NRQL)
and advanced visualization tools supports performance
analysis, pattern recognition, and failure point
prediction. Thus, New Relic plays a key role in
optimizing distributed systems by ensuring continuous
monitoring and diagnostics, even under extreme loads.
Microservices typically have multiple entry points (API
Gateway, services, Event Brokers), necessitating a
comprehensive approach to authentication and
encryption. OAuth 2.0 or OpenID Connect should be
used for REST/gRPC interactions [1], while TLS should
be implemented at the service-to-service level (Mutual
TLS) or via a service mesh (such as Istio), ensuring
transparent encrypted communication between
microservices [4].
For a detailed understanding of the advantages and
limitations of various performance optimization
methods, the summary in Table 2 is presented below.
The American Journal of Engineering and Technology
130
https://www.theamericanjournals.com/index.php/tajet
Table 2. Summary analysis of the main methods and tools for optimizing performance in MSA (compiled by
the author, based on [4-6]).
Method / Tool
Advantages
Limitations / Risks
Application
Recommendations
Containerization
(Docker)
-
Convenient
deployment
-
Environment
isolation
-
Fast
portability
-
Overhead
in
inter-
container communication -
Requires proper resource
management
Use for fast and flexible
delivery;
carefully
configure CPU/Memory
limits and network layers
Orchestration
(Kubernetes)
- Service autoscaling
- Fault tolerance
mechanisms
-
Centralized
configuration
-
Increased
setup
complexity
-
Requires
knowledge
of
specific
resources
(Deployment,
Ingress, HPA)
Apply in production for
cloud
environments
requiring
horizontal
scaling
CQRS
- Reduces database
contention
-
Optimizes
read/write
operations
separately
-
Increased
code
complexity
-
Requires
additional synchronization
between models
Useful for systems with
significantly
different
read and write profiles
Event Sourcing
- Full history of state
changes - Simplified
integration of events
with analytics
-
Complex
state
reconstruction - Risk of
growing storage size due to
event accumulation
Suitable for cases where
historical
data
transparency
and
transaction traceability
are critical
Caching
(Redis,
Memcached)
-
Significantly
reduces
response
time - Decreases
database load
-
Risk
of
cache
inconsistency - Requires
TTL
(time-to-live)
management
Effective for frequently
repeated queries to the
same data
Tracing systems
(Zipkin)
-
Detailed
identification
of
bottlenecks
-
Improved
latency
diagnostics
- Increased load due to
detailed log collection -
Requires integration of
agents into all services
Use for large distributed
systems
where
interaction transparency
is critical
Thus,
performance
optimization
in
high-load
microservices systems requires a comprehensive
approach.
Experimental evaluation of the proposed solutions
Evaluation is a critical stage in verifying the proposed
methods for optimizing the performance of
microservices architecture (MSA). Below is a case study
illustrating the development and testing of a high-load
system implementing the previously described
The American Journal of Engineering and Technology
131
https://www.theamericanjournals.com/index.php/tajet
approaches.
To demonstrate the effectiveness of the recommended
methods and tools, a prototype e-commerce system (E-
commerce prototype) was developed, consisting of the
following microservices:
1.
Catalog Service
–
stores and provides information
about products, including metadata, prices, and
stock availability.
2.
Order Service
–
processes orders, manages
statuses, and calculates the final cost, including
discounts.
3.
Payment Service
–
simulates a payment gateway,
handling authorization and transaction processing.
4.
User Service
–
manages user registration,
authentication, and account operations.
5.
Notification Service
–
sends notifications to
customers via email and push notifications.
All services were deployed in Docker containers and
orchestrated using Kubernetes (K8s). The primary goal
of the experiment was to assess how the combination
of architectural patterns (CQRS, Event Sourcing, event-
driven communication) and optimization mechanisms
(autoscaling, caching, load balancing) impacts system
performance and stability as the number of concurrent
users increases.
Key performance metrics were collected during testing,
including average latency, maximum transactions per
second (TPS), and error rate (Errors%). Table 3 presents
a comparative analysis of different configurations
under a mixed scenario (browsing the catalog and
placing orders). For clarity, the data is provided for
2,000 and 5,000 concurrent users.
Table 3. Results of load testing in various configurations of the microservices architecture [6].
Configuration
Avg Latency,
ms
(2,000
users)
TPS
(2,000
users)
Avg Latency,
ms
(5,000
users)
TPS
(5,000
users)
Errors%
Baseline MSA (no CQRS, caching,
or autoscaling)
650 ± 25
820 ±
30
980 ± 40
1000 ±
60
~1.2%
MSA with CQRS and caching
(Redis), no autoscaling
420 ± 20
1050 ±
40
750 ± 25
1300 ±
55
~0.9%
MSA with CQRS, caching, and
autoscaling (K8s HPA)
300 ± 15
1300 ±
50
500 ± 20
1550 ±
60
~0.5%
MSA
with
CQRS,
caching,
autoscaling, and Event Sourcing
(Kafka)
280 ± 10
1400 ±
45
450 ± 20
1700 ±
70
~0.5%
The results of the experiment demonstrate that
effectively optimizing the performance of high-load
microservices systems requires a combination of the
following elements:
1.
Containerization and orchestration (Docker +
Kubernetes) for dynamic autoscaling and simplified
service management.
2.
Architectural patterns (CQRS, Event Sourcing) to
separate read and write operations and reduce
database contention.
3.
Message brokers (Kafka) to facilitate asynchronous
processing of high-volume transactional requests
and minimize latency.
The American Journal of Engineering and Technology
132
https://www.theamericanjournals.com/index.php/tajet
4.
Caching of frequently requested data (Redis),
particularly for catalog queries, providing a
significant improvement in response times.
5.
Comprehensive monitoring (Prometheus, Grafana,
Jaeger) and a structured testing framework (load
and stress tests) to diagnose bottlenecks and
ensure timely scalability.
CONCLUSION
This study examined the key theoretical aspects,
methods, and tools influencing the performance of
microservices architecture in high-load systems. A
review of contemporary literature revealed that
transitioning to a microservices-based development
model addresses various challenges related to system
scalability and updates while introducing new
complexities associated with distribution, fault
tolerance, and service coordination.
In practice, effective optimization is achieved through a
comprehensive
approach:
microservices
are
containerized using Docker, orchestrated with
Kubernetes, and utilize event brokers such as Kafka.
Key architectural patterns include CQRS, Event
Sourcing, and various autoscaling mechanisms.
Additionally, the implementation of monitoring
systems (Prometheus, Grafana) and tracing tools
(Jaeger) enables the identification of bottlenecks and
facilitates rapid responses to workload changes.
The conducted experiments demonstrated that the
combination of these solutions reduces latency,
increases throughput, and enhances system stability
even under a significant increase in the number of
active users. However, the broad range of available
tools and possible implementation scenarios suggests
the need for further research in modeling optimal
autoscaling strategies, cache management, and
selecting
the
most
efficient
microservices
communication protocol (REST, gRPC, or event-driven
messaging). Expanding and validating this methodology
on real industrial projects will contribute to the
development of more universal recommendations for
improving performance and fault tolerance in modern
distributed systems.
REFERENCES
Bass L., Clements P., Kazman R. // Software
Architecture in Practice (4th ed.). Addison-Wesley
Professional.
–
2021.
–
pp.1-13.
Belnar A. Building Event-Driven Microservices:
Leveraging Organizational Data at Scale. USA.
–
2020.
–
pp. 5-10.
Lewis J., Fowler M. Microservices: a definition of this
new architectural term //MartinFowler. com.
–
2014.
–
Vol. 25 (14-26).
–
pp. 12.
Li S. et al. Understanding and addressing quality
attributes of microservices architecture: A Systematic
literature
review
//Information
and
software
technology.
–
2021.
–
Vol. 131.
–
P. 106449.
Newman S. Building microservices.
–
" O'Reilly Media,
Inc.", 2021.
–
pp.55-79.
Shumilov M. I. Optimization of high-load web projects
using microservice architecture // Universum: technical
sciences.
–
2024.
–
Vol. 2 (11).
–
pp. 4-10.
Zhang H., Babar M. A. Systematic reviews in software
engineering: An empirical investigation // Information
and software technology.
–
2013.
–
Vol. 55 (7).
–
pp.
1341-1354.
Torkura K. A. et al. Cloudstrike: Chaos engineering for
security and resiliency in cloud infrastructure // IEEE
Access.
–
2020.
–
Vol. 8.
–
pp. 123044-123060.
