This document discusses high performance architecture patterns for building scalable systems. It covers patterns like isolating critical components, reducing components to reduce problems, implementing redundancy through health checks, evaluating data consistency versus availability based on the CAP theorem, using pools of resources, implementing controlled timeouts and resource consumption, caching data closer to applications, different load balancing strategies, adopting decoupled and asynchronous architectures, discovering bottlenecks through testing, and implementing telemetry through tools like Grafana and InfluxDB. The document provides an overview of essential patterns for architecting highly performant and scalable systems.

1. High Performance
Architecture Patterns
Celso Crivelaro
@celsocrivelaro

2. $ whoami > Celso Crivelaro
- Engineer and MSc in Computer Engineering
- Dev Ruby / Python / Java
@celsocrivelaro
http://crivelaro.me

5. SMTP Locaweb
- Transaction email platform
- Fast and high quality email sending
- Live reports
- Integration by SMTP Protocol and HTTP API
- 2,5 Millions of messages per day
- + 2 years

7. Platforms

12. High Availability

13. Resource Consumption

15. Disk
Memory
Band-
width
Processor
time
Logs
GC
Open
Connections
Deadlocks
Stop all disk activities
Swap
Slowness
Services stop
responding
Queues Amount
Workers
Slowness

16. Integrations

17. Integrations always
fails!

18. Integration Fails always
Internal
External
DB API Storage Network
API ISP HopCloud

19. Map hidden
integrations
E.g. DNS

20. Fail Fast

21. Failing Fast reduces
transient errors

22. Timeouts

23. Never trust in
default timeouts

24. Threads Timeouts to get rid of deadlocls
Internal Little timeout
External Depends: The least possible

25. Retry

26. 1 2 3 5 8 n
Fibonacci Proportion
...

27. Isolate Critical
Components

28. Panel / API
Painel Web Internal API - HTTP
Resources
Connection
Pool
App Server
Business
Rules
Integrations

29. App Internal APIApp Panel
Painel Web API - HTTP
Resources
Conn.
Pool
App
Server
Business
Rules
Integrations
Resources
Conn.
Pool
App
Server
Business
Rules
Integrations

30. Less Components
==
Less Problems

32. Redundancy

33. Health Check

36. Scalability

37. CAP Theorem

38. Availability
Consistency
Tolerance
to network
partition

39. Availability
Consistency
Partition
Tolerance
to network
partition
whether system is
available or not

40. Availability
Consistency
Tolerance
to network
partition
Same data in all nodes

41. Availability
Consistency
Tolerance
to network
partition
Tolerante when a network
fails

42. Availability
Consistency
Partition
Tolerance
Postgres

43. Availability
Consistency
Partition
Tolerance
DNS

44. Availability
Consistency
Partition
Tolerance
Protocols

45. Evaluate which one is
acceptable to your
platform

46. Pool of Resources

47. App
Connection
Resource
Connection
Connection
Connection
Connection

48. Controlled Timeouts
Controlled Resource Consumption
Avoid opening/closing connections
overhead

49. Cache

50. Make your data closer
to your app

51. When use cache
App API
DB

52. Default Cache Strategy
App
Cache
Source
1
2
3

53. Hot Cache Strategy
App Cache Source
2 1

54. Load Balacing

55. LB
App
App
App
App

56. Load Balance Strategy
matters!

57. Decoupled
Architecture

58. Slow Processing
Fast processing
Asynchronous Processing
Authentication
Message
Transformation
MTA ProvidersUser
Message
Persistence
Consolidation

59. Background jobs
Messaging frameworks

60. How to discover
bottlenecks?

61. Test your limits...
Load Test
Stress Test
Peak Test

62. Telemetry

64. Grafana + InfluxDB

65. Other scalabity
patterns

66. Indexes

67. Sharding

68. References

72. http://use-the-index-luke.com

74. Thank you!
Celso Crivelaro
@celsocrivelaro
celsocrivelaro@gmail.com