The ability of a system to respond gracefully to an unexpected hardware or software failure. There are many levels of fault tolerance, the lowest being the ability to continue operation in the event of a power failure. Many fault-tolerant computer systems mirror all operations -- that is, every operation is performed on two or more duplicate systems, so if one fails the other can take over. In most cases it could be achieved by redundancy in application design and set of patterns and approaches to software design.

1. Fault Tolerance
look, it’s simple!

2. ● just baked father
● SA at EPAM Systems
● primary skill is Java
● hands-on-coding with Groovy, Ruby
● trying to get in touch with Erlang/Elixir
● passionate about agile, clean code and devops

3. Agenda
● Why should I care?
● Philosophy
● Tools
● Patterns
● Design Concepts
● Demo
● Summary
● Q&A

4. Why Should I
Care?..

5. 1500 USD / second
90 000 USD / minute
5 400 000 USD / hour
x 6
BMW 6 Series Gran Coupé

6. 1800 USD / second
108 000 USD / minute
6 480 000 USD / hour
x 6
Jaguar F-Type S

7. Philosophy

8. Everything Crashes

9. Let It Crash

10. Fail Fast

11. Try Again

12. It’s all about
Fault Tolerance
Resiliency
Availability
Production

13. Tools

14. JRugged https://github.com/Comcast/jrugged
A Java library of robustness design
patterns that makes your Java code
more rugged
- implements some common patterns like
Circuit Breaker, Limited Retries etc;
- provides straightforward add-ons to existing
code;
- performance monitoring capabilities

15. Hystrix https://github.com/Netflix/Hystrix
Latency and Fault Tolerance for
Distributed Systems
- isolates points of access to remote systems,
services and 3rd party libraries;
- stops cascading failure;
- enables resilience in complex distributed systems
where failure is inevitable;
- real-time monitoring and configuration changes;
- parallel execution;

16. Patterns

17. #1 Timeout

18. #2 Circuit Breaker

19. #2 Circuit Breaker

20. #3 Fail Fast

21. #3 Fail Fast

22. #4 Shed Load

23. #4 Shed Load

24. #5 Deferrable Work

25. #5 Deferrable Work

26. #6 Limited Retries

27. #6 Limited Retries

28. More …
● Fallback
● Cached Fallback
● Fail silent
● Bulkheads
● ...

29. Design
Concepts

30. #1 Modularity
● Small components = understandable
● Single Responsibility Principle
● Loose coupling high cohesion
● Microservices?..

31. #2 Redundancy
● Avoid single point of failure
● Avoid data sits in one place

32. #3 Asynchronicity
● Non-blocking operations
● Messaging
● Reactive

33. #4 Immutability
● Code
● State and Data
● Infrastructure

34. Demo Time

35. Demo App Architecture

36. ● Systems are distributed
● Systems are becoming even more distributed…
● Failures are the normal case
● Failures are not predictable
● Fault tolerant = scalable
● It’s all about availability of production system
Summary

37. References

38. ● http://en.wikipedia.org/wiki/Fault_tolerance
● http://martinfowler.com/bliki/CircuitBreaker.html
● https://github.com/Netflix/Hystrix
● https://github.com/webdizz/fault-tolerance-talk

39. Q&A

40. Izzet Mustafayev@EPAM Systems
@webdizz webdizz izzetmustafaiev
http://webdizz.name