Please enable JavaScript.

Coggle requires JavaScript to display documents.

(Design principles (High cohesion (Single focus Single…

Design principles

High cohesion

Single focus

    Single responsibility (SOLID)


    Encapsulation


    Easily re-writable code (Smaller code bases)


    Why



        Scalable


        Reliable


        Flexible

Autonomous

Loose coupling

    Honor contracts and interfaces


    Stateless


    Independently changeable


    Independently deployable


    Backward compatibility


    Concurrent developmnet

Business domain centric

Service represents business function

    Scope of service


    Identify boundaries


    Responsive to business change

ReSilience

Embrace failure

        Another service


        Third party system




    Degrade functionality


    Default functionality


    Multiple instances



        Register on start up


        Deregister on failure




    Types of failure



        Exceptions / Errors


        Delays


        Unavailability




    Network issues



        Delays


        Unavailability




    Validate input



        Service to service


        Client to service

Automation

Tools to reduce testing

        Manual regression testing


        Time taken on testing integration


        Environment set up for testing




    Tools to provide quick feedback



        Integration feedback on check in (CI)




    Tools to prvide quick deployments



        Automated deployments


        Reliable deployements


        Continuos deployments




    Why



        Distributed systems


        Multiple instances of services


        Manual integration testing takes too long


        Manual deployment time consuming and unreliable

Observable

System health

        Logs


        Status


        Errors




    Centralized monitoring


    Centralized logging


    why?



        Distributed transactions


        Quick problem solving


        Quick deployments require feedback (We use automated deploy tools)


        Data used for capacity planing and scaling


        What is actually used

Introduction

Microservices

Microservices is basically SOA "done well". Microservices provide

    Efficient scalability


    Flexibility


    High performance



  Microservice is a single service with a single focus. Does one thing and one thing well.



    Independent data storage


    Independently changeable


    Independently deployable


    Distributed transactions


    Lightweight communication mechanism (both client-service and service-service)

Monolithic

Typical enterprice apps. We end up with large code base.

    Longer dev time


    Longer deployment time


    Technology stack is fixed


    High level of coupling



        between modules


        between services




    Failure could affect entire system


    Scaling requires duplication of the whole


    Single service on server is an advantage, dev is easily done

Why now?

Need to respond to change quickly

    Need for reliability (If one part break down, we still have other running parts)


    Automated test tools,  release and deplyment tools are available and they make things easy


    On-demand hosting (cloud / clone)

Benefits

Shorter dev time (different parts can be done by different teams)

    Reliable and faster deployments (Enables frequent updates)


    Decouple the changeble parts


    Security (data is distributed, can have different security implementations for different services)


    Increased uptime (Only one service will be down at a time)


    Highly scalable and better performance (can duplicate necessary services to better performance)


    Better ownership and knowledge