SCS - Self-contained Systems

The Self-contained System (SCS) approach is an architecture that focuses on a separation of the functionality into many independent systems. This presentation explains SCS in detail.

Transcript

1. Self-contained Systems: A Different Approach to Microservices
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 > Independent deployment units > E.g. process, VMs, Docker containers > Any technology > Any infrastructure Micro Service Micro Service
7. Components Collaborate Micro Service Micro Service Link Data Replication REST Messaging
8. Online Shop Order Catalog Search Billing Customer HTML / HTTP
9. Distributed System
10. Distributed System Why??
11. Why Microservices? Strong Modularization Scaling Agile Sustainable development Replaceable Services Continuous Delivery Free choice of technology Handle Legacy efficient Independent Scaling Robustness Small teams develop and deploy independently Add services – not code Small Services Failure limited to single Microservice
12. Why Microservices? Scaling Agile Sustainable development Continuous Delivery Free choice of technology Handle Legacy efficient Independent Scaling Robustness Organization Deployment Units Technology
13. Single Developer Scaling Agile Sustainable development Continuous Delivery Free choice of technology Handle Legacy efficient Independent Scaling Robustness Organization Deployment Units Technology
14. Replace Monolith Scaling Agile Sustainable development Continuous Delivery Free choice of technology Handle Legacy efficient Independent Scaling Robustness Organization Deployment Units Technology
15. Self-Contained System (SCS)
16. Deployment monolith Graphics by Roman Stranghöhner, innoQ http://scs-architecture.org
17. Various Domains
18. User interface Business logic Persistence
19. … a lot of modules, components, frameworks and libraries
20. With all these layers in one place, a monolith tends to grow.
21. Cut Deployment monolith along domains …
22. … wrap domain in separate web application …
23. Self-contained System (SCS) – individually deployable
24. Decentralized unit communicating with other systems via RESTful HTTP or lightweight messaging.
25. SCS can be individually developed for different platforms.
26. An SCS contains its own user interface, specific business logic and separate data storage
27. Web user interface composed according to ROCA principles. http://roca-style.org
28. optional API e.g. for mobile
29. Logic only shared over a well defined interface.
30. Business logic can consist of microservices
31. Every SCS brings its own data storage with ist own (potentially redundant) data
32. Redundancies: tolerable as long as sovereignty of data by owning system is not undermined.
33. Enables polyglot persistence Neo4J CouchDB Oracle
34. Technical decisions can be made independently from other systems (programming language, frameworks, tooling, platform)
35. Domain scope enables development, operation and maintenance of SCS by a single team. Team 1 Team 2 Team 3
36. Self-contained Systems should be integrated in the web interface
37. Hyperlinks to navigate between systems. System 1 System 2
38. System 1 System 2 Redirection > Use of callback URIs > As seen e.g. in OAuth flows
39. Dynamic inclusion of content served by another application System 1 System 2
40. Synchronous remote calls inside the business logic should be avoided.
41. Asynchronous Remote calls reduce dependencies and prevent error cascades.
42. Data model’s consistency guarantees are relaxed.
43. An integrated system of systems like this has many benefits.
44. Resilience is improved through loosely coupled, replaceable systems.
45. SCSs can be individually scaled to serve varying demands.
46. No risky big bang to migrate an outdated, monolithic system into a system of systems. Version 1 Version 2
47. Migration in small, manageable steps which minimize risk of failure and lead to an evolutionary modernization of big and complex systems.
48. 1 *Microservice SCS
49. Conclusion > SCS: autonomouos web application > Might consist of Microservices > Focus on UI Integration > Almost completet independence > Coarse-grained architecture approach
50. Conclusion > Self-contained systems are Microservices … > that are not “micro”… > and don’t have to be “services” > Many are doing it already!
51. > http://scs- architecture.org > Creative commons > Source on Github > Slidedeck