A pattern language for microservices

CHRIS RICHARDSON FOUNDER, EVENTUATE
When architecting an enterprise Java application, you need to choose between the traditional monolithic architecture consisting of a single large WAR file, or the more fashionable microservices architecture consisting of many smaller services. But rather than blindly picking the familiar or the fashionable, it’s important to remember what Fred Books said almost 30 years ago: there are no silver bullets in software. Every architectural decision has both benefits and drawbacks. Whether the benefits of one approach outweigh the drawbacks greatly depends upon the context of your particular project. Moreover, even if you adopt the microservices architecture, you must still make numerous other design decisions, each with their own trade-offs. A software pattern is an ideal way of describing a solution to a problem in a given context along with its tradeoffs. In this presentation, we describe a pattern language for microservices. You will learn about patterns that will help you decide when and how to use microservices vs. a monolithic architecture. We will also describe patterns that solve various problems in a microservice architecture including inter-service communication, service registration and service discovery.

1. @crichardson
A pattern language for
microservices
Chris Richardson
Founder of Eventuate.io
Founder of the original CloudFoundry.com
Author of POJOs in Action
@crichardson
[email protected]
http://microservices.io
http://eventuate.io
http://plainoldobjects.com

2. @crichardson
Presentation goal
Why patterns and pattern
languages?
A pattern language for
microservices

3. @crichardson
About Chris

4. @crichardson
About Chris
Consultant and trainer
focusing on modern
application architectures
including microservices
(http://www.chrisrichardson.net/)

5. @crichardson
About Chris
Founder of Eventuate, Inc
Creating a platform that makes it
easy for application developers to
write microservices
(http://eventuate.io)

6. @crichardson
For more information
https://github.com/cer/event-sourcing-examples
http://microservices.io
http://plainoldobjects.com/
https://twitter.com/crichardson
http://eventuate.io/

7. @crichardson
Agenda
Why a pattern language for microservices?
Core patterns
Deployment patterns
Communication patterns and more

8. @crichardson
In 1986…
http://en.wikipedia.org/wiki/Fred_Brooks

9. @crichardson
Yet almost 30 years later
developers are still
passionately arguing over
“silver bullets”

10. @crichardson
Popular silver bullets
Functional programming

11. @crichardson
Suck/Rock Dichotomy
Spring vs. Java EE
JavaScript vs. Java
Functional programming vs. Object-oriented
http://nealford.com/memeagora/2009/08/05/suck-rock-dichotomy.html
Containers vs. Virtual Machines

12. @crichardson
Gartner Hype Cycle
http://upload.wikimedia.org/wikipedia/commons/b/bf/Hype-Cycle-General.png
It’s
awesome
It’s not
awesome
Trade-offs
understood

13. @crichardson
How we make decisions
Decide
using
emotions
Rationalize with
our intellect
http://en.wikipedia.org/wiki/Mahout

14. @crichardson
We need a better way
to discuss and think
about technology

15. @crichardson
What’s a pattern?
Reusable solution
to a problem
occurring
in a particular context

16. @crichardson
The structure of a pattern
=
Great framework for discussing
and thinking about technology

17. @crichardson
The structure of a pattern
Resulting context
aka the situation
Name
Context
Problem
Related patterns
(conflicting) issues
etc to address
Forces
Solution

18. @crichardson
Resulting context
Benefits
Drawbacks
Issues to resolve

19. @crichardson
Related patterns
Alternative solutions
Solutions to problems
introduced by this pattern

20. Pattern language
A collection of related
patterns that solve problems
in a particular domain
Relationships
Pattern A results in a
context that has a problem
solved by Pattern B
Patterns A and B solve the
same problem
Pattern A is a
specialization of pattern B
http://en.wikipedia.org/wiki/A_Pattern_Language
Access to Water
Promenade
Local townhall
Intimacy gradient
Light on two sides

21. @crichardson
Meta-pattern
Problem: How to talk/reason about technology?
Solution: Use the pattern format
Benefit: More objective
Drawback: Less exciting
Context: Emotional software development culture
Related patterns: It’s awesome!

22. @crichardson
Work
in
progress
http://microservices.io/
Monolithic
architecture Microservice
architecture
API gateway
Client-side discovery
Server-side
discovery
Service registry
Self registration3rd party registration
Multiple Services
per host
Single Service per
Host
Service-per-
Container
Deployment
Discovery
Data
Communication
Service-per-VM
Partitioning
Messaging
Remote Procedure
Invocation
Style
Core
Database per
Service
Event-driven
architecture
Event
sourcing
Motivating
Pattern
Solution
Pattern
Solution A Solution B
General Specific

23. @crichardson
Agenda
Why a pattern language for microservices?
Core patterns
Deployment patterns
Communication patterns and more

24. @crichardson

25. @crichardson
Let’s imagine you are
building an online store
Browser/
Client
SQL
Database
Review Service
Catalog
Service
Recommendation
Service
StoreFrontUI
Order Service
HTML
REST/JSON

26. @crichardson
Problem: what’s the
deployment architecture?

27. @crichardson
Forces
Businesses must innovate
faster
<z
Develop more complex,
higher-quality software faster

28. @crichardson
Forces
Developers must be productive
The code must be easy to understand and modify
Continuous deployment of applications
Developers must leverage emerging technologies
(frameworks, programming languages, etc)
Deploy multiple application instances for scalability and
availability

29. @crichardson
Tomcat
Pattern: Monolithic
architecture
Browser/
Client
WAR/EAR
MySQL
Database
Review Service
Catalog
Service
Recommendation
Service
StoreFrontUI
Order Service
HTML
REST/JSON

30. @crichardson
Examples everywhere

31. @crichardson
Simple to ….
Develop
Test
Deploy
Scale

32. @crichardson
Successful applications
have a habit of growing
<z
Big, complex, monolithic
applications

33. @crichardson
Agile development and deployment
becomes impossible

34. @crichardson
Intimidates developers

35. @crichardson
Obstacle to frequent
deployments
Need to redeploy everything to change one component
Interrupts long running background (e.g. Quartz) jobs
Increases risk of failure
Fear of change
Updates will happen less often - really long QA cycles
e.g. Makes A/B testing UI really difficult
Eggs in
one basket

36. @crichardson
Scaling the application can be
challenging
Memory intensive CPU intensive
IO intensive
Conflicting
Needs

37. @crichardson
Overloads your IDE and
container
Slows down development

38. @crichardson
Lots of coordination and
communication required
Requires lots of coordination
I want to update
the UI
But
the backend is not working
yet!

39. @crichardson
Requires long-term
commitment to a
technology stack

40. @crichardson
Pattern: Microservice
architecture

41. @crichardson
Apply functional
decomposition
X axis
- horizontal duplication
Z axis - data partitioning
Y axis -
functional
decomposition
Scale by splitting similar
things
Scale by
splitting
different things

42. @crichardson
Catalog
Microservice architecture
Catalog
Service
Recommendation
Service
Review
Service
Order
Service
Browse Products
UI
Checkout UI
Order management
UI
Account
management UI
Apply X-axis and Z-axis scaling
to each service independently

43. @crichardson
Goal of partitioning:
Most changes affect only a single
service
<z
Develop and deploy independently
in parallel with other changes

44. @crichardson
Goal of partitioning:
Separate components with
conflicting resource
requirements
<z
Scale more easily

45. @crichardson
http://highscalability.com/amazon-architecture
http://techblog.netflix.com/
http://www.addsimplicity.com/downloads/
eBaySDForum2006-11-29.pdf
http://queue.acm.org/detail.cfm?id=1394128
~600 services
100-150 services to build a page
Examples of microservices

46. @crichardson
http://bit.ly/msexample_yelp
http://bit.ly/msexample_soundcloud
http://bit.ly/msexample_uber
Examples of microservices

47. @crichardson
Benefits
Smaller, simpler apps
Easier to understand and develop
Less jar/classpath hell - who needs OSGI?
Faster to build and deploy
Scales development: develop, deploy and scale each service independently
Improves fault isolation
Easier scaling
Eliminates long-term commitment to a single technology stack
System level architecture vs. service level architecture
Easily and safely experiment with new technologies

48. @crichardson
Drawbacks
Complexity

49. @crichardson
Drawbacks
Complexity of developing a distributed system
Implementing inter-process communication
Handling partial failures
Implementing business transactions that span multiple databases
(without 2PC)
Complexity of testing a distributed system
Complexity of deploying and operating a distributed system
Managing the development and deployment of features that span
multiple services
Fortunately solutions exists

50. @crichardson
The benefits typically
outweigh the drawbacks
for
large, complex applications

51. @crichardson
Issues to address
How to deploy the services?
How do the services communicate?
How do clients of the application communicate with the
services?
How to partition the system into services?
How to deal with distributed data management problems?
….

52. @crichardson
Agenda
Why a pattern language for microservices?
Core patterns
Deployment patterns
Communication patterns and more

53. @crichardson
We have applied the
microservices pattern:
How to deploy the services?

54. @crichardson
Forces
Services are written using a variety of languages, frameworks, and framework
versions
Each service consists of multiple service instances for throughput and
availability
Building and deploying a service must be fast
Service must be deployed and scaled independently
Service instances need to be isolated
Resources consumed by a service must be constrained
Deployment must be reliable
Deployment must be cost-effective

55. @crichardson

56. @crichardson
Pattern: Multiple service
instances per host
Host (Physical or VM)
Service-A
Instance-1
Service-B
Instance-2
Service-C
Instance-2
Process
WAR
OSGI bundle

57. Benefits and drawbacks
Benefits
Efficient resource utilization
Fast deployment
Drawbacks
Poor/Terrible isolation
Poor visibility (with WAR/OSGI
deployment)
Difficult to limit resource utilization
Risk of dependency version
conflicts
Poor encapsulation of
implementation technology

58. @crichardson
Pattern: Service instance per
host

59. @crichardson
Pattern: Service per VM host
Service
VM
image
VM
Service
VM
Service
VM
Service
packaged as
deployed as

60. @crichardson
Example
http://techblog.netflix.com/
~600 services
packer.io is a great tool

61. Benefits and drawbacks
Benefits
Great isolation
Great manageability
VM encapsulates
implementation technology
Leverage AWS
infrastructure for
Autoscaling/Load balancing

Drawbacks
Less efficient resource
utilization
Slow deployment

62. @crichardson
VM
VM
Pattern: Service per Container
host
Service
Container
image
Container
Service
Container
Service
Container
Service
packaged as
deployed as

63. @crichardson

64. @crichardson
Docker clustering solutions
https://www.dchq.io/landing/index.html

65. Benefits and drawbacks
Benefits
Great isolation
Great manageability
Container encapsulates
implementation technology
Efficient resource utilization
Fast deployment
Drawbacks
Immature infrastructure for
deploying containers

66. @crichardson
Agenda
Why a pattern language for microservices?
Core patterns
Deployment patterns
Communication patterns and more

67. @crichardson
Communication issues
System Client
Service A
Service B
Service C
The System
How do clients of the
system interact with the
services?
How do services
within the system
interact?

68. @crichardson
How do external clients
interact with the microsevices?

69. @crichardson
How do services communicate
with each other?

70. @crichardson
How does a client determine the
network location of a service?

71. @crichardson
What’s the database
architecture?

72. Database per Service
Orders Service
Customer
Service
Order
Database
Customer
Database
Sharded SQL
NoSQL DB

73. How to solve distributed data
management challenges?
How to implement
transactions that span
multiple services?
How to implement queries
that span multiple
services?

74. @crichardson
Summary: Patterns and pattern
languages are a great way to …
Think about technology
Discuss technology
Apply technology

75. @crichardson
Summary: The Microservices pattern
language is a great way to …
Think about microservices
Discuss microservices
Apply microservices (or not)

76. @crichardson
@crichardson [email protected]
http://eventuate.io
http://plainoldobjects.com http://microservices.io
Questions?