What Microservices are and how Microservices help to support agile software development.

1. Microservices:
Architecture for Agile
Software Development
Eberhard Wolff
Fellow, innoQ
@ewolff

3. http://microservices-buch.de/ http://microservices-book.com/

4. http://microservices-book.com/primer.html
FREE!!!!

5. Microservice
Definition

6. Server Server
Microservices:
Definition
> Small
> Independent deployment units
> Separate VM / process
> Any technology
> Any infrastructure
Micro
Service
Micro
Service

7. Components Collaborate
Micro
Service
Micro
Service
Link
Data Replication
REST
Messaging

8. Microservices
> Component Model
> Component…
> Individual deployment unit
> GUI+Logic?

9. Layered
iOS Android Web
Order Search Catalog
BillingCustomer
Backend Backend Backend

10. Layered
> Reusable Backend Services
> Mobile client / Web App as frontend
> Backend for frontend (BFF): Custom
backend services
> ...to implement frontend specific logic

11. Layered: Issues
> All BFF support the same processes
> BFF contain most relevant logic
> Change to a business process means
changing many services
> Lots of communication

12. Self-contained
Systems
Order Search CatalogBilling
Web Web Web Web

13. Self-contained
Systems (SCS)
> SCS: Autonomous web application
> Optional service API (e.g. for mobile clients)
> Includes data & logic
> Might contain several microservices
> No shared UI
> No shared business code
> E.g. Otto, Kaufhof ...

14. SCS: Benefits
> Business logic for one domain in one SCS
> Change usually local to one SCS
> Less communication between SCS
> I think this should be the goal
> http://scs-architecture.org

15. Online Shop
Order
Catalog
Search
Billing
Customer
HTML /
HTTP

16. Online Shop
Elasticsearch
Spring Batch
Oracle
Spring MVC
MongoDB
Order
Catalog
Search
Billing

17. Agility

18. Agile Manifesto
> Individuals and Interaction
> Over processes and tools
> Working Software
> Over comprehensive documentation
> Customer Collaboration
> Over contract negotation
> Responding to change
> Over following a plan

19. Agile Manifesto:
Individuals and
Interactions

20. Software Architecture
& Individuals

21. Software Architecture
& Individuals
Unrelated?

22. Does Your
Architecture Take
Individuals Into
Account?

23. Conway‘s Law
Architecture
copies
communication structures
of the organization

24. Conway‘s Law: Impact
Architecture
and
communication structures
in the organization
are the same thing.

25. Conway’s Law as a
Limit
> Organization drives architecture
> I.e. GUI, logic & database team
> Three technical artifacts

26. E Commerce
Shop
Change
Order
Process!
UI
Backend
DB

27. time
DB
Team Sprint
Backend
Team Sprint
UI
Team Sprint
3 sprints

28. Deployment Monolith
Deployment Monolith
Stories
Technical Coordination
Coordinating Releases

29. Order SearchBilling
Team for each business feature
Let architecture drive the organization
Order Billing Search

30. Deployment Monolith
+ Conway’s Law
Deployment Monolith
Stories
Technical Coordination
Coordinating Releases
StoriesStories
Order Billing Search

31. Microservices +
Conway’s Law
> Let architecture drive the organization
> Team for each Microservice
> Team responsible for business features
> Ideal: Independent features

32. Order SearchBilling
Order Billing Search
Team can deploy without integration
Changes can be deployed independently & quickly
Strong & enforced modularization
Technology stack per Microservice
One or many Microservices per Team
Synergy Microservices / Conway’s Law

33. Microservices
Microservice
Stories
Technical
Coordination
Microservice
Stories
Technical
Coordination
Microservice
Stories
Technical
Coordination
Order Billing Search
Release Release Release

34. How to scale agile?

35. Define
architecture to
limit
communication
needs

36. One team can build and
deploy features
independently!

37. Team must be
responsible for a
sensible set of
functionality

38. Less Technical
Coordination

39. Agile Manifesto:
Working Software

40. Scrum
> PSI
> Potentially shippable increment
> Why?

41. Principles behind the
Agile Manifesto
Our highest priority is
to satisfy the customer
through early and
continuous delivery
of valuable software.

42. Potentially
Shippable
Increment
Continuous
Delivery

43. Monolith
ECommerce
System
3rd party
systems
Database

44. Continuous Delivery:
Build Pipeline
ECommerce
System
Commit
Stage
Automated
Acceptance
Testing
Automated
Capacity
Testing
Manual
Explorative
Testing
Release

45. Build Pipeline:
Complex Infrastructure
> Huge database
> 3rd party integration

46. Build Pipeline:
Slow Feedback
> Slow feedback
> Test everything for each commit
> Huge deployment unit
> Deployment slow

47. Monolith:
Deployment
> Huge deployment
> Risky
> Hard to mitigate risk
> Blue / Green: Create a separate
environment
> Canary: Deploy to one server first

48. Microservices
ECommerce
System
3rd party
systems
Database

49. Microservices
3rd party
systems
Database
Order
Catalog
Billing
Search

50. Order
Billing
Customer
Commit
Stage
Automated
Acceptance
Testing
Automated
Capacity
Testing
Manual
Explorative
Testing
Release
Commit
Stage
Automated
Acceptance
Testing
Automated
Capacity
Testing
Manual
Explorative
Testing
Release
Commit
Stage
Automated
Acceptance
Testing
Automated
Capacity
Testing
Manual
Explorative
Testing
Release

51. Build Pipeline for
Microservices
> Independent deployment
> Build pipeline per Microservice
> Small
> Easier to set up
> Less features (3rd party systems)
> Faster Feedback: Less tests

52. Microservice:
Deployment
> Small deployment
> Less risky
> Other Microservices resilient to failing
microservice
> Easy to create new environments
> E.g. for Blue / Green or Canary

53. Quick Deployments
Time
Size & Risk
Manual
Deployment
Pipeline
Continuous
Delivery
Pipeline
Monolith
Microservices

54. Potentially shippable
increment?

55. SHIP!!!

56. Agile Manifesto:
Customer
Collaboration

57. Customer
Collaboration &
Architecture?

58. Microservices &
Departments
StoriesStories Stories
Customer Billing
Order
Process
Product
Owner
Product
Owner
Product
Owner
Department Department Department

59. Microservices &
Departments
> Ideal: One team per department
> Ideal: Change local to one team /
Microservice
> Otherwise: Coordination needed

60. Customer should own
Microservice

61. Agile Manifesto:
Responding to change

62. Monoliths
> Architecture rot
> …not maintainable any more
> …and can’t be rewritten / replaced

63. Deployment Monolith
> Cyclic dependency
> …because the IDE suggested some class
> Might not even be noticed
Module
Class
Module
Class
Class Class

64. Microservices
> Need to use the API
> Different team
> More effort - will think about it
> Rot less likely
Microservice
Class
Microservice
Class
Class Class

65. Global Refactorings?
> Move code from service to service
> Might be a port to a different language
> Separate in a new service
> Harder than in a Deployment Monolith

66. Microservices
> Small
> Easy to change
> Architectural problems in Microservice unlikely
> Can be replaced
Microservice
Class
Class

67. Microservices
– Easy to Recycle

68. Conclusion

69. Conclusion:
Microservices & Agility
> Individuals over tools
> Architecture drives organization
> Scale by architecture not process
> Working software
> Actually ship software
> Continuous Delivery

70. Conclusion:
Microservices & Agility
> Customer collaboration
> Customer should own services
> i.e. organization beyond the project =
architecture

71. Conclusion:
Microservices & Agility
> Responding to change
> Individual Microservices small
> Easy to change
> …and replace
> Unwanted dependencies won’t sneak in
> But: Global refactoring hard, too

72. Meta-Conclusion

73. How To Think About
Architecture
> Process has an impact on architecture
> Software architecture & organization are the
same
> Build recyclable software!

74. Microservice > Agile
Achitecture
Strong Modularization
Scaled Agile Architecture
Sustainable development
speed Replaceable Services
Continuous Delivery
Choose best technology
for job!
Handle Legacy more efficient
Independent Scaling
Robustness

75. Thank You!
@ewolff
https://github.com/ewolff/microservice
https://leanpub.com/microservices-primer
http://microservices-buch.de/
http://scs-architecture.org