Please enable JavaScript.

Coggle requires JavaScript to display documents.

M8 elasticity P1 (generic concept (client side caching ? (cache in browser…

- - - - example
        
        by default
        
        disk activity, RDS usage
  - - - has just started, the metric is not available
    - - Threshold exceed
    - - Threshold not exceeded
- - - - Monitoring metric will change
      - so that we can know
- - - - Time to live (TTL) is an integer value that specifies the number of seconds until the key expires.
      - Redis specify seconds or milliseconds for this value.
      - When an application attempts to read an expired key, it is treated as though the key is not found.
      - This approach doesn't guarantee that a value isn't stale. However, it keeps data from getting too stale
      - and requires that values in the cache are occasionally refreshed from the database
      - The database is queried for the key and the cache is updated.
- - - - Number of nodes required?
        
        For example, if your memory requirement is 13GB, you may want to use two cache.m4.large nodes instead of using one cache.m4.xlarge nod
        
        Need to know total memory required, divide that memory into enough nodes such that your application can survive the loss of one or two nodes.
      - I am using Memcache currently. Can i migrate to elastic cache
        
        yes,
        
        open standard (=same as Redis)
        
        Is Protocol-compliant with Memcached.
      - Feature
        
        Scaling ??
        
        Write and memory scaling is supported with sharding.
        
        Replicas provide read scaling.
        
        if node fail, auto replace with a new node
        
        new node get the same DNS and IP
        
        .
        
        default maintenance window is 60 minute :DT
      - limitation
        
        No supoort Multi-Az, read replica , backup and restore
      - support Multi-threaded ?
        
        This means that you can handle more operations by scaling up compute capacity.
        
        can make use of multiple processing cores.
      - used case
        
        You need the simplest model possible.
        
        You need to run large nodes with multiple cores or threads.
        
        You need the ability to scale out and in, adding and removing nodes as demand on your system increases and decreases.
        
        You need to cache objects, such as a databas
    - - Database protocol
      - feature
        
        support primary DB, read replica, Multi-AZ backup and snpahot
      - support adavanced data structure
        
        sorted set and list ,array
      - youtube
        
        AWS ElastiCache Tutorial - 01 Creating ElastiCache for Redis
      - How to access
        
        Using Redis client to access
      - cluster
        
        consists of multiple shard
        
        Each shard consist of 1 primary node and multiple replica
        
        Increase write by having shards ????
      - Pub/Sub ?
        
        Red is suitable for Chat App
        
        Allow subscriber to subcriber multple channel from Publisher
        
        channels like stock, sport and wheter
    - - both also are open source
      - reside in your VPC
- - - - Your app write to dynamoDB
      - DynamoDB write toDAX
      - your app read the DynamoDB
      - DAX will intercept