Microservices and Redis: A perfect match

Microservices and Redis: A Match made in Heaven
April 26th 2018

SUPERCHARGE MICROSERVICES WITH REDIS
Vijay Vangapandu
Software Architect
https://www.linkedin.com/in/vijayvangapandu

• Our comprehensive & revealing Relationship Questionnaire
• 29 Dimensions® of Compatibility
• 15+ million matches per day globally
(20+ billion since inception)
• 100+ thousand photos uploaded per day
• 1+ million communications per day
Who is eharmony?

eharmony core product

Product Experience
COMPATIBILITY AFFINITY SELF-SELECT PROFILE

Product Experience
Match Listing CommunicationMatch Profile Dashboard

A microservice is a single self-contained unit which, together with
many others, makes up a large application.
Microservices

Benefits Of Microservices
Developer Independence
Small teams work in parallel and can iterate faster.
Eliminates any long-term commitment to a
technology stack.
Isolation and resilience
If a component dies, you spin up another while the
rest of the application continues to function.
Scalability
Smaller components take up fewer resources and
can be scaled to meet increasing demand of that
component only.
Relationship to the business
Microservice architectures are split along business
domain boundaries, increasing independence and
understanding across the organization

Benefits Of Microservices
1. Number of deployments per day
2. Time To Market the new features
3. Service availability
4. Number of production issues
Continues deployment
integration with slack

Login Public API (Gateway)
Profile Matches Comm Badging NewsfeedPhotos Config
Match Profile DashboardInbox
Message bus
Nodejs App Stack
Eharmony Microservices Architecture
CMP User ActivityUser Pairings Scorer/Modeling
Event ListenerMatching Batch Jobs
User ServiceMatch Maker
Aggregation Services
Core Services
Persistance
Matching

Public API (Gateway)
Profile Matches
Communication
BadgingPhotos
Message bus
Communication flow between services
Dashboard
Newsfeed
Match Profile
Matching services/jobs

• Redis is an open source (BSD licensed),
• In-memory data structure key-value store
• Can be used as a database, cache and message broker.
• Primary – Replica architecture
• Provides high availability via Redis Sentinel
• Automatic partitioning with Redis Cluster
• Rich set of operations on various data structures
• Client libraries for almost all popular languages
• Large adoption and great community support
• Single threaded and supports atomic operations
What is redis?

Redis data structures
Strings
Binary-safe strings is most commonly used data
structure to store simple key-value data.
Lists
Collection of string elements sorted in insertion
order (linked lists).
Sets
Collection of unique, unsorted string elements.
Sorted sets
Similar to set with every element associated to
floating number value, called SCORE. Supports
range queries.
Hashes
Which are maps composed of fields associated with
values. Both the field and value are strings.
HyperLogLogs
Probabilistic data structure used in order to count
unique things.

Redis deployment options
M
S SSnapshot/AOF
• Persistence
• Snapshot for periodic backup
• AOF for every write ( more reliable)
• Replication
• Data will be replicated to read-only slaves
• Failover : Manual
M
S S
• Persistence
• Replication
• Failover :
• Automatic failover through sentinel
Sent
inel
Sent
inel
Sent
inel
S1
• Persistence
• Flash optimized storage with redis labs cluster
• Replication
• Failover :
• Automatic failover through cluster
M2
M1
S2
Keys A - N
Keys O - Z

Redis use-cases @eharmony

Login Public API (Gateway)
Profile Matches Comm Badging NewsfeedPhotos
Nodejs App Stack
Redis as auth store
Refresh tokens Access tokens

Redis as auth store
• Simple string key-value based store
• Token as key and Auth object as value
• Access token has shorter TTL
• Refresh has longer TTL
• JEDIS client library ( SpringData)
• Leveraging RedisLabs replication

Redis as auth store
JedisPoolConfig poolConfig = new JedisPoolConfig();
JedisConnectionFactory cf = new JedisConnectionFactory();
cf.setHostName({hostname}); cf.setPort({port});
cf.setPoolConfig(poolConfig );
RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(cf);
redisTemplate.opsForValue(). set(tokenKey, accesstoken, duration, CACHE_TTL_UNITS);
redisAccessTokenTemplate.opsForValue().get(tokenKey);
redisAccessTokenTemplate.delete(accessToken.getTokenId());
-bash-4.1$ ./redis-cli -p XXXX
127.0.0.1:XXXX> get "661295e5-0e4c-XX”
"{"atVal":"661295e5-0e4c-XX",""authorities":[...}”
127.0.0.1:XXXX> ttl "661295e5-0e4c-XX”
(integer) 132888
Client Configuration
Operations
Redis CLI

Redis as auth store - Performance

Matching
User
Service
Message bus
Redis as matching user store
CMP User Activity
User TimelinePairingsMatch maker
Scorer
Modeling
FeatureX
User Store
MAS
Matching Batch Jobs Matching Event Listener

• Hashes data structure
• Data stored in binrary format - Protocol buffers
• UserId as key
• Various user data sections as categories for Map keys
• Ex: User Info, Photos, Activity
• Leveragin RedisLabs cluster with 6 shards
• Leveraging RedisLabs Flash storage

public Map<String, V> fetchValues(final Iterable<String> keys) {
List results = redisTemplate.executePipelined(new SessionCallback<Object>() {
public Object execute(RedisOperations operations) {
Iterator var2 = keys.iterator();
while(var2.hasNext()) {
operations.opsForHash().entries((String)var2.next());
}
}});
operations.watch(key);
byte[] hashValue = (byte[])hashOperations.get(key, hashKey);
T value = valueSerializer.deserialize(hashKey, hashValue);
value = merger.merge(key, value);
byte[] mergedHashValue = valueSerializer.serialize(hashKey, value);
operations.multi();
hashOperations.put(key, hashKey, mergedHashValue);
List<Object> execResult = operations.exec();
//deserialize to proto...
if(hashKey.equalsIgnoreCase("user-activity"))
return ActivityProto.parseFrom(hashValue);
Fetch Entries in batch
Partial updates
”user:123”:
“activity”: {},
”profile”:{},
“photos”:{},
“questionnaire”:{},
”user:124”:
“activity”: {},
”profile”:{},
“photos”:{},
“questionnaire”:{},

Profile Matches Comm
Badge API
Photos
Redis as badges store
Badge Store
Badge
Processor
Message bus

Redis as badges store
• Hashes data structure
• Leveraging atomic counters
• UserId as key
• Various badge categories as Map keys
• Ex: Photos, Matches, Activity
• Accumulators as values
• Leveraging RedisLabs Flash storage

Redis as Badges Store
HashOperations<String, String, String> hashOps = redisTemplate.opsForHash();
hashOps.increment(“user:123”, “matches”, 1 );
hashOps.increment(“user:123”, “favorite”, -1 * decrementByCount);
hashOps. delete(“user:123”, “matches”);
127.0.0.1:XXXX> hincrby user:123 matches 10
127.0.0.1:XXXX> hincrby user:123 favorite -2
127.0.0.1:XXXX> hdel user:231 favorite
Operations
Redis CLI
“user:123”:
“matches”:24,
“communication”:2,
“photos-new”: 5
“favorite”: 3
“user:231”:
“matches”:3,
“communication”:1,
“photos-new”: 0
“favorite”: 2
HINCRBY

Redis as Badges Store
port 5002
sentinel monitor master-badeges {masternode ip} {port} 1
sentinel down-after-milliseconds master-badges 10000
sentinel failover-timeout master-badges 20000
sentinel config-epoch master-badges 94
# Generated by CONFIG REWRITE
sentinel leader-epoch master-badges 96
sentinel known-slave master-badges {slavenode ip} {port}
sentinel known-sentinel master-badges {sentinel2} 5002 eb42be8
sentinel known-sentinel master-badges {sentinel3} 5002 9243503
sentinel current-epoch 96
Sentinel Configuration
M
S S
• Persistence
• Replication
• Failover :
• Automatic failover through sentinel
Sent
inel
Sent
inel
Sent
inel

Match Save
Service
Redis as speed store in lambda architecture
Delta Store
Message bus
Match Query
Service
Batch Store
Match Events
Processor
Match creation jobs

CDN
Redis sorted sets for Security
Delta Store
Gateway/Router
Profile Matches Comm NewsfeedPhotos
Admin
Login
Refresh tokens Access tokensAccess Tokens Refresh Tokens
Block/unblock
IP/User Agent
Logs
Aggregates
Block Access
Block Access

Redis sorted sets for Security
• Connecting redis from spark jobs
• Leveraging Sorted Sets to find the top N anomalies to block
• Single threaded atomic operations better suited to store accumulators from spark
• Leveraging kafka window operation for streaming
• Leveraging sentinel for auto failover

Redis sorted sets for security
ZSetOperations<String, String> zsetOps = redisTemplate.opsForZSet();
Double score1 = zsetOps.incrementScore("ipList", "10.23.43.11", 67);
Double score1 = zsetOps.incrementScore("ipList", "121.23.54.1", 20);
Double score1 = zsetOps.incrementScore("ipList", ”210.2.4.34", 345);
Set<String> annomilies = zsetOps.rangeByScore("ip-blacklist", 50, 200);
Results:
10.23.43.11, 210.2.4.34
127.0.0.1:XXXX> zadd ip-blacklist 10 "10.2.3.4”
127.0.0.1:XXXX> zadd ip-blacklist 200 "100.23.45.67"
127.0.0.1:XXXX> zrange ip-blacklist 0 -1
1) "10.2.3.4”
2) "100.23.45.67"
Operations
Redis CLI
import redis.clients.jedis.{Jedis, ScanParams, ScanResult}
jedis.zadd(key, dataToStore)
jedis.watch(key) val transaction = jedis.multi()
transaction.hset(key, valueData.value, JsonUtil.toJson(valueData))
transaction.expire(key, redisTtl)
transaction.exec()
val result:List[ValueData]= jedis
.zrangeByScoreWithScores(key, minScore, maxScore)
.asScala.toList
.map((tuple: Tuple) => JsonUtil.toValueData(tuple.getElement))
Java Scala

Redis sorted sets for security
API BOT mitigation

Redis pub/sub for configurations
Config Service
ServiceServiceServiceService ServiceServiceServiceService ServiceServiceServiceService
Redis Pub/Sub
Gateway

Many more use cases…
• Redis can be used as hibernate second level cache
• Using Redis to rate control the API usage by IP/UA in securely
• Actively migrating user service to Redis using hashes
• Planning to migrate newsfeed, profile and pairings stores

Redis labs cluster solution

Redis monitoring and alerting

Redis modules in mix!
• RedisSearch
• rebloom
• Redis Graph
• Redis-timeseries
• Session Gate
• ReJSON
• Redis-cell
• Redis-ML
• topk
• ReDe
https://redis.io/modules

Microservices and Redis: A perfect match

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Microservices and Redis: A perfect match

Similaire à Microservices and Redis: A perfect match (20)

Plus de Redis Labs

Plus de Redis Labs (20)

Dernier

Dernier (20)

Microservices and Redis: A perfect match