This document summarizes a presentation on microservices patterns and practices. It introduces microservices architecture and its benefits, such as enabling continuous delivery, improved fault isolation, and eliminating long-term commitment to technology stacks. It then covers several data patterns for microservices including shared database, one database per service, CQRS, and event sourcing. Integration patterns like service discovery, circuit breakers, API gateways, and sagas are also discussed. The document concludes by exploring testing, operations, and deployment patterns for microservices.

1. Microservices
Patterns & Practice
Rafael Monteiro
TICNOVA 2018
Maringá – PR

2. Formado em Ciência
da Computação pela
Universidade
Presbiteriana
Mackenzie
Mestrando em
Inteligência Artificial
Software Engineer /
Data Scientist

3. Agenda
Introduction to Microservices
Data Patterns
Integration Patterns
Testing Microservices
Operations
Deployment

4. Introduction to
Microservices

5. Monolithic
Architecture

6. Microservices
Architecture

7. Microservices Architecture
• This solution has a number of benefits:
• Enables the continuous delivery and deployment of large, complex
applications.
• Smaller and faster to test
• Services can be deployed independently
• Each microservice is relatively small
• Easier to understand
• The application starts faster, which makes developers more productive, and
speeds up deployments
Source: https://microservices.io/patterns/

8. Microservices Architecture
• Improved fault isolation
• Eliminates any long-term commitment to a technology stack.
Source: https://microservices.io/patterns/

9. Data Patterns

10. Shared Database

11. One Database
per service

12. CQRS
• How to implement queries
in a microservice
architecture?

13. Event
Sourcing
How to reliably/atomically
publish events whenever state
changes?

14. Integration
Patterns

15. Service Discovery
Service
registry
Client-side
service
discovery
Server-side
service
discovery

16. Client-side service discovery

17. Server-side service discovery

18. Eureka

19. Circuit Breaker
How to prevent a network or service failure from cascading to other services?

20. Circuit Breaker
• Services handle the failure of the
services that they invoke
• It is challenging to choose timeout
values without creating false
positives or introducing excessive
latency.

21. Hystrix

22. API
Gateway

23. Contract First

24. API
Gateway

25. Saga Pattern
• Problem
• Each service has its own
database
• How to maintain data
consistency across
services?

26. Saga Pattern

27. Saga Pattern

28. Saga Pattern

29. Messaging
•Services communicating
by exchanging messages
over messaging channels.

30. Data Source
hell...

31. Much better….

32. Schema
Registry

34. Testing your
Microservices

35. Contract Testing

36. Contract Testing

38. Operations

39. Log aggregation
How to understand the behavior of an application and troubleshoot
problems?
Use a centralized logging service that aggregates logs from each service
instance. The users can search and analyze the logs. They can configure
alerts that are triggered when certain messages appear in the logs.

40. Log aggregation

41. Health Check API
•How to detect that a
running service instance
is unable to handle
requests?

42. Health Check API
This pattern has the following drawbacks:
The health check might not sufficiently comprehensive or the service instance might fail between health
checks and so requests might still be routed to a failed service instance
The health check endpoint enables the health of a service instance to be
periodically tested

43. Health Check API
• A service has an health check API endpoint
(e.g. HTTP /health) that returns the health
of the service. The API endpoint handler
performs various checks, such as
• the status of the connections to the
infrastructure services used by the
service instance
• the status of the host, e.g. disk space
• application specific logic

44. Health Check API

45. Application
metrics
Prometheus , New Relic ,
AppDynamics, Grafana +
InfluxDB.
How to understand the
behavior of an application and
troubleshoot problems?

46. Distributed tracing
How to understand the
behavior of an application
and troubleshoot problems?
Assigns each external request
a unique external request id
Passes the external request
id to all services that are
involved in handling the
request
Includes the external request
id in all log messages
Records information (e.g.
start time, end time) about
the requests and operations
performed when handling a
external request in a
centralized service

47. Distributed tracing
Ex: Spring Cloud Sleuth

48. Deployment

49. Deployment Patterns
Single Service
Instance per
Host
Multiple service
instances per
host
Service Instance
per VM
Service instance
per container
Service
deployment
platform

50. Deployment Patterns

51. References
• Livro Migrating to Microservice
Databases – Edson Yanaga
• https://microservices.io/
• http://www.confluente.io
• https://www.enterpriseintegrationpatt
erns.com/
• https://www.nginx.com/blog/introduct
ion-to-microservices/
• https://en.paradigmadigital.com/dev/s
pring-cloud-microservices-architecture-
12/
• https://dzone.com/articles/distributed-
sagas-for-microservices

52. E-mail: rafael@monteiro.io
Github:
github.com/rafamonteiro
LinkedIn:
https://bit.ly/2jQQIXj
Obrigado!!!!
Feedback ? Contato ?