Distributed Systems Section 2

[berkeli]

Read the doc

[berkeli]

Questions:

• What is a cache hit rate and why is it important?
  • hit rate shows how many queries are served from cache vs how many server from database
• What do we mean by ‘cold’ or ‘warm’ when we discuss caches?
  • Cold means cache doesn't yet have data (perhaps the service just started or has been flushed) hit rate will be close to 0. Warm means the cache has data and most queries can be served from cache without hitting database.
• Why do we use consistent hashing when we shard data?
  • This allows to retain most of the keys when number of partitions changes. Consistent hashing is a practice of mapping keys to data partition so we know which keys can be invalidated if a partition needs to be removed/restarted, etc
• When should we consider sharding a cache rather than replicating it?
  • When there's a lot of data, when it can't be served from one machine (or it can be but still a bad idea in case it needs to be restarted)
• Why do we need cache invalidation?
  • To serve our users with the most up-to-date data, avoid inconsistencies in data.
• What is a TTL used for in caching?
  • Time to live, the amount of time cache should be kept in memory after which it will be removed from memory.
• Why should we cache in a standalone cache service, as opposed to within our application?
  • Our application can potentially have many deployments, updates and all of them would refresh cache when code is deployed and machine restarts.

[berkeli]

• What are the challenges associated with recovering from a failed database replica?
  • The main challenge for restarting a follower is to pick up from where it has left off (failed). It will need to check local logs, and query the leader to pick up from the latest log entry to restore data
  • When it comes to the Leader failing, another leader will have to replace it and this could mean that the data not yet processed by followers will be lost.

[illicitonion]

Good insights!

• What is a TTL used for in caching?

  • Time to live, the amount of time cache should be kept in memory after which it will be removed from memory.

"removed from memory" is interesting phrasing here. There are two different styles of TTLs: "remove this from memory after this time" and "consider this entry invalid (but don't necessarily remove it from memory) after this time" - can you think when each may be more useful?

Also, can you think of a strategy for bounding the size of a cache which doesn't involve a TTL?

• Why should we cache in a standalone cache service, as opposed to within our application?

  • Our application can potentially have many deployments, updates and all of them would refresh cache when code is deployed and machine restarts.

This is a good reason - can you think of others?