scalecube-services
MICROSERVICES 2.0
|
An open-source project that is focused on streamlining reactive-programming of Microservices Reactive-systems that scale, built by developers for developers. ScaleCube Services provides a low latency Reactive Microservices library for peer-to-peer service registry and discovery based on gossip protocol, without single point-of-failure or bottlenecks. Scalecube more gracefully address the cross cutting concernes of distributed microservices architecture. |
|
- Provision and interconnect microservices as a service-mesh (cluster)
- Reactive Streams support.
- Fire And Forget - Send and not wait for a reply
- Request Response - Send single request and expect single reply
- Request Stream - Send single request and expect stream of responses.
- Request bidirectional - send stream of requests and expect stream of responses.
- No single-point-of-failure or single-point-of-bottleneck
- Cluster aware and distributed
- Modular, flexible deployment models and topology
- Zero configuration, automatic peer-to-peer service discovery using gossip
- Simple non-blocking, asynchronous programming model
- Resilient due to failure detection, fault tolerance, and elasticity
- Routing and balancing strategies for both stateless and stateful services
- Low latency and high throughput
- Takes advantage of the JVM and scales over available cores
- Embeddable to existing Java applications
- Natural Circuit-Breaker due to tight integration with scalecube-cluster failure detector.
- Support Service instance tagging.
- pluggable api-gateway providers (http / websocket / rsocket)
- pluggable service transport
- pluggable encoders
User Guide:
- Services Overview
- Defining Services
- Implementing services
- Provisioning Clustered Services
- Consuming services
Basic Usage:
The example provisions 2 cluster nodes and making a remote interaction.
- seed is a member node and provision no services of its own.
- then microservices variable is a member that joins seed member and provision GreetingService instance.
- finally from seed node - create a proxy by the GreetingService api and send a greeting request.
//1. ScaleCube Node node with no members
Microservices seed = Microservices.builder().startAwait();
//2. Construct a ScaleCube node which joins the cluster hosting the Greeting Service
Microservices microservices =
Microservices.builder()
.discovery(
self ->
new ScalecubeServiceDiscovery(self)
.options(opts -> opts.seedMembers(toAddress(seed.discovery().address()))))
.transport(ServiceTransports::rsocketServiceTransport)
.services(new GreetingServiceImpl())
.startAwait();
//3. Create service proxy
GreetingsService service = seed.call().api(GreetingsService.class);
// Execute the services and subscribe to service events
service.sayHello("joe").subscribe(consumer -> {
System.out.println(consumer.message());
});Basic Service Example:
- RequestOne: Send single request and expect single reply
- RequestStream: Send single request and expect stream of responses.
- RequestBidirectional: send stream of requests and expect stream of responses.
A service is nothing but an interface declaring what methods we wish to provision at our cluster.
@Service
public interface ExampleService {
@ServiceMethod
Mono<String> sayHello(String request);
@ServiceMethod
Flux<MyResponse> helloStream();
@ServiceMethod
Flux<MyResponse> helloBidirectional(Flux<MyRequest> requests);
}API-Gateway:
Available api-gateways are rsocket, http and websocket
Basic API-Gateway example:
Microservices.builder()
.discovery(options -> options.seeds(seed.discovery().address()))
.services(...) // OPTIONAL: services (if any) as part of this node.
// configure list of gateways plugins exposing the apis
.gateway(options -> new WebsocketGateway(options.id("ws").port(8080)))
.gateway(options -> new HttpGateway(options.id("http").port(7070)))
.gateway(options -> new RSocketGateway(options.id("rsws").port(9090)))
.startAwait();
// HINT: you can try connect using the api sandbox to these ports to try the api.
// http://scalecube.io/api-sandbox/app/index.htmlMaven
With scalecube-services you may plug-and-play alternative providers for Transport,Codecs and discovery. Scalecube is using ServiceLoader to load providers from class path,
You can think about scalecube as slf4j for microservices - Currently supported SPIs:
Transport providers:
- scalecube-services-transport-rsocket: using rsocket to communicate with remote services.
Message codec providers:
- scalecube-services-transport-jackson: using Jackson to encode / decode service messages. https://github.com/FasterXML
- scalecube-services-transport-protostuff: using protostuff to encode / decode service messages. https://github.com/protostuff
Service discovery providers:
- scalecube-services-discovery: using scalecue-cluster do locate service Endpoint within the cluster https://github.com/scalecube/scalecube-cluster
Binaries and dependency information for Maven can be found at http://search.maven.org.
https://mvnrepository.com/artifact/io.scalecube
To add a dependency on ScaleCube Services using Maven, use the following:
<properties>
<scalecube.version>2.x.x</scalecube.version>
</properties>
<!-- -------------------------------------------
scalecube core and api:
------------------------------------------- -->
<!-- scalecube apis -->
<dependency>
<groupId>io.scalecube</groupId>
<artifactId>scalecube-services-api</artifactId>
<version>${scalecube.version}</version>
</dependency>
<!-- scalecube services module -->
<dependency>
<groupId>io.scalecube</groupId>
<artifactId>scalecube-services</artifactId>
<version>${scalecube.version}</version>
</dependency>
<!--
Plugins / SPIs: bellow a list of providers you may choose from. to constract your own configuration:
you are welcome to build/contribute your own plugins please consider the existing ones as example.
-->
<!-- scalecube transport providers: -->
<dependency>
<groupId>io.scalecube</groupId>
<artifactId>scalecube-services-transport-rsocket</artifactId>
<version>${scalecube.version}</version>
</dependency>