Source-linked AI summary
Microservices: How To Make Your Application Scale
Nicola Dragoni, Ivan Lanese, Stephan Thordal Larsen, Manuel Mazzara, Ruslan Mustafin, Larisa Safina
TL;DR
The paper examines how microservices address scalability needs by organizing applications into small, bounded, independently operated services. It describes these architectural features and their use in scaling resources, replicas, and availability, while noting administrative and platform-related limitations.
Problem
Monolithic systems and large-granularity services make it difficult to scale only the components experiencing load, limiting non-uniform scalability.
Method
The paper describes microservices’ principles and examines how independent services, containers, dynamic replication, and orchestration support scalable systems.
Results
Microservices provide mechanisms for dynamically adding or removing hosts and service replicas, while replication and independence support availability during updates and hardware failures.
Takeaways & Limitations
Microservices offer a natural way to pursue scalability, including availability and fault tolerance, by decomposing systems into independently scalable services.
Takeaways & Limitations
Microservices introduce administrative overhead for deployment, administration, monitoring, and security, and remain difficult to apply to resource-constrained, security-sensitive Internet-of-Things devices.
Abstract
from arXiv · showhide
The microservice architecture is a style inspired by service-oriented computing that has recently started gaining popularity and that promises to change the way in which software is perceived, conceived and designed. In this paper, we describe the main features of microservices and highlight how these features improve scalability.
1 Introduction
Microservices extend service-oriented ideas into system design through small, bounded, independently operated services. These principles align system structure with business capabilities and support maintainability, evolution, and scalability.
- Microservices address a broader shift toward distribution, modularization, and loose coupling intended to improve code reuse, robustness, and software quality.The paper situates microservices within the evolution of programming languages, paradigms, and service-oriented architectures.
- Microservices move service-oriented techniques from system integration into system design, development, and deployment by organizing applications around small services.
- Bounded Context combines related functionalities into one business capability, aligning business capabilities with system structure.This alignment makes it easier to locate functionality for updates or fixes.
- Small services can be refined from larger services and rebuilt or modified with limited resources and time.The paper presents small size as a crucial novelty relative to previous service-oriented architectures.
- Operational independence uses loose coupling, high cohesion, and published interfaces as the sole communication mechanism between services.A service can be changed, fixed, or upgraded without compromising system correctness when interfaces are preserved.
2 Scalability
Microservices improve scalability by distributing workload and allowing independently deployed services to scale according to localized demand. Replication, elasticity, isolation, and independent updates also support availability and fault tolerance, although shared-host interference and administrative overhead remain constraints.
- Distribution: Microservices distribute workload across independently deployable services, enabling more efficient operation and better geographical scalability than monoliths.Services can be placed near clients and failures in one service need not cause failure in others.
- Non-uniform scaling: Independent processes allow microservices to be monitored and scaled separately, avoiding the coarse-grained scaling required by monolithic architectures.Domain-Driven Design and high cohesion typically delimit growing load to a subset of associated services.
- Elasticity: Elasticity lets systems add or remove hosts, virtual machines, and service replicas as load changes, using cloud resources efficiently.The same mechanism supports dynamic expansion under high load and de-provisioning when resources become redundant.
- Availability: Replication and independent deployment improve availability by spreading services across locations and allowing updates with reduced downtime.Old and new service versions can run side by side, leading to smaller but more frequent updates.
- Robustness: Isolation and replication improve fault tolerance, but dependent services still require mechanisms to detect failures and prevent cascading failures.A failed microservice is isolated from others except through defined interfaces and shared resources.
- Constraints: Shared-host deployments can suffer low-level resource interference, and microservices add administrative overhead in deployment, monitoring, administration, and security.Placement must account for service load so that one service does not exhaust shared resources; some problems may remain insufficiently mitigated.
3 The Language Choice
The paper presents Jolie as a dedicated language for microservice systems, with each program defined as a microservice and deployment information. Jolie supports distribution and non-uniform scalability, while containerization and elasticity remain outside its specific language support.
- The Language Choice: The authors argue that a dedicated language can simplify microservice-system development, drawing on their experience with Jolie.Microservice architectures can also combine a wide range of technologies.
- Jolie: In Jolie, each program is a microservice described by behavior and deployment information specifying communication with other microservices.Each microservice exposes functionality at a specific URL and can be invoked by other microservices.
- Jolie: Jolie supports non-uniform scalability through new instances, dynamically changeable invocation targets, load balancers, redirection, and aggregation.The language has no specific support for containerization or elasticity, and the benefits of adding such support remain under discussion.
4 Applications
Microservices support applications that require scalability, minimality, and cohesiveness by separating logic into small, focused components. The smart-building application uses this structure to manage changing sensors, actuators, faults, and monitoring needs.
- Microservice architecture is presented as suitable where scalability, minimality, and cohesiveness are required.
- The smart-building system separates logic into small components, with each service managing one sensor or specific function.
- This decomposition supports sensor reusability because the central data-extraction logic remains unchanged when sensors are added, removed, or replaced.
- Readability and reusability reduce bugs, while scalability and cohesiveness support connecting devices, managing faults, and monitoring changing infrastructure.
- Service orchestration and workflow management are needed because elasticity is handled partly automatically and partly through human intervention from a central control panel.
5 Microservices and Beyond
The paper situates microservices within established software paradigms while describing language-based development and ongoing adoption efforts. It also identifies security, tooling, verification, and cloud–IoT integration as unresolved challenges.
- Microservices relate to established paradigms such as object-oriented programming and service-oriented architecture, with prior work emphasizing evolutionary development.
- Microservices can combine technologies, while a language-based approach is presented as a way to simplify development.
- Jolie natively supports microservices, whereas WS-BPEL supports high-level orchestration but lacks fine-grained procedural constructs for internal service logic.
- The research team contributed type-system extensions, static type checking, iterative controls, and inline documentation to broaden Jolie’s adoption.
- Security, commercial-quality development packages, fully verified software, and integration with cloud and Internet-of-Things platforms remain open challenges.
- Internet-of-Things integration is especially difficult because many devices have limited computational capabilities and higher security risks.