This document discusses the creation of reactive microservices with Java, highlighting the differences between monoliths and microservices, and emphasizing a variety of concepts such as resilience, configuration management, and asynchronous communication. It details tools and frameworks like Spring Cloud and Netflix OSS for implementing these microservices, alongside code examples showcasing reactive programming principles. The presentation concludes with references to further resources and a demo link for practical application.

1. Criando Micro-serviços Reativos com Java
Rodrigo Cândido da Silva
@rcandidosilva

2. About Me
• Software Architect
• http://integritastech.com
• JUG Leader do GUJavaSC
• http://gujavasc.org
• Twitter
• @rcandidosilva
• Contatos
• http://rodrigocandido.me

3. Agenda
• Monolito vs. Micro-serviços
• Manifesto Reativo
• Resiliência
• Message-driven
• Demo
• Perguntas

4. Monolito vs. Micro-serviços

5. Micro-serviços
• Pequenos
• Deployment interdependente
• Independente de tecnologia
• Infra-estrutura separada
"Small independent component with well-
defined boundaries that’s doing one thing, but
doing it well"

6. Manifesto Reativo

7. Resiliência
• Como suportar isso com micro-serviços?
• Central point of configuration
• Service registry and discovery
• Routing features
• Load balancing
• Failover
• Monitoring

8. Spring BootSpring Cloud
Spring Cloud + Netflix OSS

9. Spring Cloud + Netflix OSS
“Casamento perfeito para criação de micro-
serviços resilientes“
Gerenciamento de Configuração Spring Cloud Config + Bus
Descoberta de Serviços Netflix Eureka
Balanceamento de Carga Netflix Ribbon
Circuit Breaker Netflix Hystrix + Turbine
Proxy Server Netflix Zuul
Segurança Spring Cloud Security

10. Spring Cloud Config

11. Netflix Eureka

12. Netflix Ribbon

13. Netflix Hystrix
• Circuit Breaker Pattern

14. Hystrix Dashboard

15. Netflix Zuul

16. Spring Cloud Security
Discovery
Client
Relying Party
Resource
Server
Get an access token
& an ID Token (JWT)
Use an access token
Authorization
Server
Iden.ty Provider or
IDP or
OpenID Provider or
OP
Authorization
Endpoint
Token
Endpoint
Important Stuff
Userinfo
Endpoint
Registration
Endpoint
JWKS
Endpoint
JWKS
Endpoint
Validate
(JWT)
ID Token
/.well-known
/webfinger
/openid-configura.on
Check Session IFrame
End Session Endpoint

17. Message-Driven
• Como suportar isso com micro-serviços?
• Comunicação assíncrona
• Non blocking I/O
• Distribuição
• Consistência
• Event sourcing
• CQRS

18. Reactive Programming
• Asynchronous communication and data streams
• reactive-streams.org

19. Alternativas Reativas com Java EE
JMS EJB 3
Message-Driven
Beans
Asynchronous
Session Beans
CDI
Events
Observers
Servlet
Asynchronous
NIO
JAX-RS
Async on Server
Async on Client
WebSocket
Async Remote
Endpoints
Concurrency
Utilities

20. Project Reactor
• Biblioteca para implementação de non-blocking apps
• Interage com Java 8 functional API
• Oferece duas composable API reativas
• Flux[N] and Mono[0|1]
• Suporta escalabilidade in-memory roteando com
Bus extensions
• Suporte portável para micro-serviços

21. REST Endpoint
@RestController
public class UserRestController {
private static final List<User> users = new ArrayList<>();
static {
users.add(new User(1, "Rodrigo", "C", "da Silva"));
users.add(new User(2, "Israel", "B", "Rodriguez"));
users.add(new User(3, "Bruno", "", "Souza"));
users.add(new User(4, "Edson", "", "Yanaga"));
}
@RequestMapping(method = RequestMethod.GET, value = "/users")
public List<User> getUsers() {
return users;
}
@RequestMapping(method = RequestMethod.GET, value = "/user/{id}")
public User getUser(@PathVariable("id") Integer id) {
return users.stream().filter(g -> g.getId() == id)
.collect(Collectors.toList()).get(0);
}
}

22. REST Proxy
@Component
public class UserServiceProxy {
@Autowired UserService service;
@HystrixCommand(fallbackMethod = "defaultUsersObservable")
public Observable<List<User>> getUsersObservable() {
return new ObservableResult<List<User>>() {
@Override
public List<User> invoke() {
return service.getUsers();
}
};
}
public Observable<User> defaultUsersObservable() {
return null;
}
} @FeignClient("USER-SERVICE")
public interface UserService {
@RequestMapping(value = "/users", method = RequestMethod.GET)
List<User> getUsers();
@RequestMapping(value = "/user/{id}", method = RequestMethod.GET)
User getUser(@PathVariable("id") Integer id);
}

23. REST Async Client
@RestController
public class APIController {
@Autowired
GroupServiceProxy groupService;
@Autowired
UserServiceProxy userService;
@RequestMapping(method = RequestMethod.GET, value = "/userGroups")
public UserGroup getUserGroups() {
Observable<List<Group>> groups = groupService.getGroupsObservable();
Observable<List<User>> users = userService.getUsersObservable();
Observable<UserGroup> userGroupObservable =
Observable.zip(groups, users, (g, u) -> new UserGroup(u, g));
return userGroupObservable.toList().toBlocking().single().get(0);
}
}

24. Demo
• Reactive Microservices
• https://github.com/rcandidosilva/reactive-microservices

25. Outras Alternativas

26. Perguntas
?

27. Referências
• http://projects.spring.io/spring-boot/
• http://projects.spring.io/spring-cloud/
• https://netflix.github.io/
• http://www.reactive-streams.org/
• http://www.reactivemanifesto.org/
• https://github.com/reactivemanifesto/website-manifesto/tree/master/public/pdf
• https://projectreactor.io/
• http://reactivex.io/
• http://www.kennybastani.com/2016/04/event-sourcing-microservices-spring-
cloud.html

28. Muito Obrigado!
@rcandidosilva
rodrigocandido.me