A gaming company has a web application that displays scores. The application runs on Amazon EC2 instances behind an Application Load Balancer. The application stores data in an Amazon RDS for MySQL database. Users are starting to experience long delays and interruptions that are caused by database read performance. The company wants to improve the user experience while minimizing changes to the application’s architecture.
What should a solutions architect do to meet these requirements?
To improve the application's read performance and minimize changes to the existing architecture, using Amazon ElastiCache in front of the database is the best approach. ElastiCache can cache frequently accessed data, significantly reducing the load on the database and improving read performance. This solution allows the application to retrieve data faster by accessing the cache instead of hitting the database for every read operation, thus enhancing the user experience. While the data may be dynamic, ElastiCache manages updates effectively to ensure consistency and freshness of the data when necessary.
Rds proxy is for too many connections, not for performance
Can't use cache as score gates updated. If data would have been static then definitely can go with A. But here score is dynamic...
Users are starting to experience long delays and interruptions caused by the "read performance" of the database... While the score is dynamic, there is also read activity in the DB that is causing the delays and outages and this can be improved with Elastic Cache.
to use elasticache , you need to perform heavy code change ,aand also elasticache do chaching that can improve read perfromance but will not provide scalability
We should "minimize", not "avoid", code changes.
minimize *architectural changes, NOT code changes
ElastiCache stores data in memory, which means it may not always have the most up-to-date information. This might be acceptable for certain use cases where slightly stale data is acceptable, but for applications like gaming scores, real-time accuracy is often crucial.
“Data in the cache is never stale. Because the data in the cache is updated every time it's written to the database, the data in the cache is always current and updated whenever data is written to the database.” https://docs.aws.amazon.com/AmazonElastiCache/latest/mem-ug/Strategies.html#Strategies.WriteThrough
RDS Proxy: It helps applications improve scalability and performance by managing database connections and pooling, which can significantly reduce the load on the database
RDX proxy will :"improve the user experience while minimizing changes".
.. but not address issues with "database read performance".
A will be the best option regarding read performance and based on following link: https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/creating-elasticache-cluster-with-RDS-settings.html
RDS Proxy: It helps applications improve scalability and performance by managing database connections and pooling, which can significantly reduce the load on the database. By using RDS Proxy, you can offload connection management tasks from your application and optimize database access, thereby improving read performance without making significant changes to the application's architecture. Minimizing Changes: Implementing RDS Proxy does not require architectural changes to the application. It works as a proxy layer between the application and the RDS database, so the application code remains unchanged. This minimizes the effort and risk associated with making modifications to the application.
Elasticache - reduce load due to read operations RDS proxy - reduce load due to lot of connections Here problem is read operations thus A is solution
The discussion is really helpful thanks everyone.
A. Use Amazon ElastiCache in front of the database: Caching frequently accessed data in ElastiCache can help reduce the load on the database and improve read performance. However, it's essential to note that while ElastiCache can significantly enhance read performance by serving frequently accessed data from memory, it might not entirely eliminate long delays and interruptions if the root cause is related to the database itself or if the caching strategy is not effectively implemented. B. Use RDS Proxy between the application and the database: Helps improve database connection management, reducing the number of open connections to the database and enhancing overall performance. RDS Proxy handles connection pooling, which means it can efficiently manage and reuse database connections, reducing the overhead of establishing new connections for each query. It supports features like read/write splitting, which directs read queries to read replicas, further distributing the load.
In this scenario, game scores are updated frequently so caching seems less useful than a proxy
Selected Answer: A ElastiCache stores data in memorY RESOLVE THE READING Issue
https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/Welcome.html
B - "Use RDS Proxy between the application and the database." B because it improves the user experience while minimizing the changes. If A is used, you have to modify your application to get the data from the cache first, if it is not there, then get from db; and also to invalidate the cache if there is a db update.
I vote for Elasticache
ask is - minimum changes. RDS Proxy is a feature of Amazon RDS. This would be easiest option to try.
A Caching frequently accessed data: ElastiCache can be used to reduce the load on your database by caching frequently accessed data. This can improve application performance and reduce the number of read queries to your database. Real-time applications: If your application requires real-time data processing, ElastiCache can help. Since it provides sub-millisecond response times, it can be used to power applications like gaming leaderboards, chat applications, and real-time analytics.
Another vague question from AWS: I would prefer A over B
Not B because this can help with connection management and improve scalability and availability but won't directly address read performance issues caused by high read traffic.
answer should be B
A for sure