My talk from http://microxchg.io/2016/index.html.
Here is the video - https://www.youtube.com/watch?v=1mcVQhbkA2U
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.
Alluxio Monthly Webinar | Cloud-Native Model Training on Distributed Data
Microservices pattern language (microxchg microxchg2016)
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
chris@chrisrichardson.net
http://microservices.io
http://eventuate.io
http://plainoldobjects.com
5. @crichardson
About Chris
Founder of Eventuate, Inc
Creating a platform that makes it
easy for application developers to
write microservices
(http://eventuate.io)
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
17. @crichardson
The structure of a pattern
Resulting context
aka the situation
Name
Context
Problem
Related patterns
(conflicting) issues
etc to address
Forces
Solution
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!
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
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
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
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!
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
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
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?
….
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
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
65. Benefits and drawbacks
Benefits
Great isolation
Great manageability
Container encapsulates
implementation technology
Efficient resource utilization
Fast deployment
Drawbacks
Immature infrastructure for
deploying containers
73. How to solve distributed data
management challenges?
How to implement
transactions that span
multiple services?
How to implement queries
that span multiple
services?