Though it is not entirely a new idea, Microservices seem to have peaked in popularity in recent years, what with numerous blogs, articles and conferences evangelizing the benefits of building software systems in this style. The coming together of trends like Cloud, DevOps and Continuous Delivery has contributed to this popularity. Designing, evolving, and versioning a microservice architecture is not trivial, and over time several design patterns and best practices have evolved. Some of the more popular patterns are Circuit – Breaker and Bulkhead.
Although it looks simple and straightforward but there are many aspects to consider while transitioning to microservices. Quite often many teams have failed in this process either because they do not educate themselves on what really means ‘doing microservices’ or by just thinking that using a specific tool suddenly you moved into this new ear. By just using Docker, Kubernetes, Neftlix libs etc you are not doing microservices. It is a far more complex process, that also needs organizational and team changes.
This session provides an overview of patterns and practices, especially considerations for fault tolerance. Some of the areas covered would be:
– What to monitor and how to monitor
– What to do when dependencies fail to respond in time
– How to develop microservices to withstand failure and incorporate fallbacks
– Considerations for a slow or saturated network
– Practical considerations for DevOps
– Overview of tools and techniques for comprehensive criteria for migrating applications to a PaaS.
– Concrete approaches for migrating apps to a PaaS including buildpacks, Service Proxy, Dockerization, Orchestration and Bosh
This session aims to provide tips and tricks for building resilient and fault tolerant microservices.
Micro services are increasingly used to tackle complexity of addressing business requirements. Understanding MicroServices architecture needs some understanding trade off involved in distributed systems. In the talk, I’ve tried to highlight how the model shifts from strong consistency to eventual consistency in Micro services. I will talk about some interesting techniques I’ve used in projects to tackle challenges posed by distributed components. I will also talk about various consistency models( viz. Read My Writes, Consistent Prefix) which developers/architects can used to make interesting tradeoffs. This is talk is going to be on architectural patterns and not related to any specific technology.
Areas covered during the talk:
● What is Live stream?
● Some video domain terminology like RTSP, HLS, DVR, Player, Transcoding, Adaptive bitrate etc
● Architecture of the application
● Challenges faced while scaling the application
● Load stats and success stories
● How we used prediction.io for generating recommendations: Recommendation system on Grails
● Use of hadoop and spark for realtime processing
● Better understanding of Video domain based and live streaming applications
● Getting started with Micro services
● How one can quickly move away from Monolith
● Spending less and still not using the Monolith approach
● How one can scale the application quickly to handle load
● On demand scaling : Auto scaling