Activity FeedActivity Feed

người dùng hoạt động mỗi ngàydaily active users

50M

người dùng hoạt động mỗi ngàydaily active users

lượt tải feed lúc cao điểmfeed loads at peak

200k/s

lượt tải feed lúc cao điểmfeed loads at peak

bài đăng mới lúc cao điểmnew posts at peak

~6k/s

bài đăng mới lúc cao điểmnew posts at peak

p99 tải một trang feedp99 to load one feed page

< 200 ms

p99 tải một trang feedp99 to load one feed page

Đường ghi và đường đọc tách riêng. Post Service lưu bài, CDC đẩy sự kiện vào Kafka, fan-out worker chèn id bài vào feed của từng follower trong Redis. Feed Service đọc feed đã tính sẵn, trộn thêm bài của người nổi tiếng, xếp hạng rồi lấy nội dung bài. Bật “Người nổi tiếng đăng bài” và “Cuộn bằng cursor” để xem hai luồng còn lại.The write path and the read path are separate. The Post Service stores the post, CDC pushes an event to Kafka, and fan-out workers insert the post id into each follower's feed in Redis. The Feed Service reads the precomputed feed, merges in celebrity posts, ranks, then loads post bodies. Turn on “Celebrity posts” and “Cursor scroll” to see the other flows.

1. 1

   Người nổi tiếng làm nổ fan-outCelebrities blow up fan-out

   Đẩy lúc ghi cho 2 triệu follower là 2 triệu ZADD và vài phút trễ. Mô hình lai: dưới ngưỡng (ví dụ 100 000 follower) thì đẩy; trên ngưỡng thì chỉ lưu vào timeline của tác giả và trộn lúc đọc. Người đọc theo dõi thường chỉ vài chục người nổi tiếng, nên trộn rẻ.Pushing to 2 million followers is 2 million ZADDs and minutes of delay. Use a hybrid: below a threshold (say 100,000 followers) push; above it store only in the author's timeline and merge on read. A reader usually follows only a few dozen celebrities, so the merge is cheap.

   Fan-out / Fan-in
2. 2

   Feed là read model, không phải nguồn dữ liệuThe feed is a read model, not the source of truth

   Post Store và Follow Graph là nguồn; feed trong Redis là bản chiếu dựng từ sự kiện, mất thì dựng lại được. Ghi qua Post Service, đọc qua Feed Service, hai đường mở rộng độc lập.The Post Store and Follow Graph are the source; the Redis feed is a projection built from events and can be rebuilt if lost. Writes go through the Post Service and reads through the Feed Service, and each scales on its own.

   CQRSProducer-Consumer
3. 3

   Phân trang bằng offset bị lặpOffset paging repeats items

   Bài mới chen vào đầu làm mọi vị trí dịch xuống. Dùng cursor (score, id): đọc score ≤ cursor, cùng score thì id nhỏ hơn. Với feed xếp hạng, chụp lại danh sách id đã xếp cho phiên (feed_session:{sid}, TTL 30 phút) rồi phân trang trên bản chụp.New posts at the top shift every position down. Use a (score, id) cursor: read score ≤ cursor and, on an equal score, smaller ids. For a ranked feed, snapshot the ranked id list per session (feed_session:{sid}, TTL 30 min) and page over the snapshot.

   Iterator
4. 4

   Bộ nhớ RedisRedis memory

   Feed chỉ chứa id và score, khoảng 50 byte mỗi phần tử; giới hạn 800 phần tử là khoảng 40 KB mỗi người. 50 triệu người hoạt động là khoảng 2 TB, nên bỏ feed của người không hoạt động 30 ngày và dựng lại khi họ quay lại. Nội dung bài lưu một lần, mọi feed trỏ tới cùng một bản.A feed holds only ids and scores, about 50 bytes an entry; an 800-entry cap is about 40 KB per user. 50 million active users is about 2 TB, so drop feeds of users inactive for 30 days and rebuild them on return. Post bodies are stored once and every feed points at the same copy.

   Flyweight
5. 5

   Xoá, ẩn và chặnDeleting, hiding and blocking

   Không xoá ngay khỏi hàng triệu feed. Đánh dấu tombstone trong Post Store, lọc khi lấy nội dung bài; job nền ZREM dần khỏi feed. Bài bị ẩn hoặc tác giả bị chặn được lọc theo danh sách riêng của từng người đọc.Never delete from millions of feeds synchronously. Mark a tombstone in the Post Store and filter at hydration time; a background job ZREMs it from feeds over time. Hidden posts and blocked authors are filtered per reader from their own lists.

   Publish-Subscribe
6. 6

   Theo dõi mới và bỏ theo dõiNew follows and unfollows

   Theo dõi mới: lấy 20 bài gần nhất của người đó từ Post Store và ZADD vào feed (backfill). Bỏ theo dõi: không quét feed ngay, lọc theo danh sách following khi đọc và để các phần tử cũ tự bị đẩy ra theo giới hạn 800.New follow: take the followee's 20 latest posts from the Post Store and ZADD them into the feed (backfill). Unfollow: do not scan the feed at once; filter by the following list on read and let old entries fall off with the 800 cap.

   Producer-Consumer
7. 7

   Xếp hạng không chỉ theo thời gianRanking beyond recency

   Lấy khoảng 3 lần số bài cần hiển thị làm ứng viên, chấm điểm theo độ mới, mức thân thiết với tác giả, tương tác dự đoán; cache điểm 5 phút. Ranking chậm hoặc lỗi thì trả theo thời gian, không làm hỏng trang.Take about three times the page size as candidates and score them on recency, affinity with the author and predicted engagement, caching scores for 5 minutes. If ranking is slow or fails, fall back to time order rather than breaking the page.

   Fan-out / Fan-in

Worker chọn đẩy hay không theo số follower. Đường đọc lấy feed đã tính sẵn cộng timeline của người nổi tiếng, trộn theo (score, id) và trả cursor của bài cuối trang.The worker decides whether to push by follower count. The read path takes the precomputed feed plus celebrity timelines, merges by (score, id) and returns the cursor of the last post on the page.

@Service
@RequiredArgsConstructor
public class FeedService {
    private static final long CELEBRITY = 100_000;
    private static final int CAP = 800;
    private final StringRedisTemplate redis;
    private final FollowGraph graph;

    @KafkaListener(topics = "post.created")
    public void fanOut(PostCreated e) {
        if (graph.followerCount(e.authorId()) >= CELEBRITY) {1
            redis.opsForZSet().add("posts:" + e.authorId(), e.postId(), e.ts()); // merged on read
            return;
        }
        for (List<Long> batch : graph.activeFollowers(e.authorId(), 1_000)) {
            redis.executePipelined((RedisCallback<Object>) c -> {2
                for (Long f : batch) {
                    byte[] key = ("feed:" + f).getBytes();
                    c.zSetCommands().zAdd(key, e.ts(), e.postId().getBytes());
                    c.zSetCommands().zRemRange(key, 0, -CAP - 1);       // keep newest 8003
                }
                return null;
            });
        }
    }

    public FeedPage page(long userId, Cursor cur, int limit) {
        List<Entry> merged = new ArrayList<>(read("feed:" + userId, cur, limit));
        for (long celeb : graph.followedCelebrities(userId))           // usually < 20
            merged.addAll(read("posts:" + celeb, cur, limit));
        List<Entry> page = merged.stream()
            .sorted(Entry.NEWEST_FIRST)                                 // score desc, id desc
            .distinct().limit(limit).toList();
        return new FeedPage(page, page.isEmpty() ? null : Cursor.of(page.get(page.size() - 1)));
    }

    private List<Entry> read(String key, Cursor cur, int limit) {
        double max = cur == null ? Double.POSITIVE_INFINITY : cur.score();
        return redis.opsForZSet()
            .reverseRangeByScoreWithScores(key, Double.NEGATIVE_INFINITY, max, 0, limit + 20)
            .stream().map(Entry::of)
            .filter(en -> cur == null || en.isBefore(cur))              // same score: smaller id only4
            .limit(limit).toList();
    }
}

type Cursor struct {
	Score float64
	ID    string
}

func (s *FeedService) Page(ctx context.Context, uid int64, cur *Cursor, limit int) ([]Entry, *Cursor, error) {
	celebs, err := s.graph.FollowedCelebrities(ctx, uid)
	if err != nil {
		return nil, nil, err
	}
	keys := []string{fmt.Sprintf("feed:%d", uid)}
	for _, c := range celebs {
		keys = append(keys, fmt.Sprintf("posts:%d", c))
	}
	parts := make([][]Entry, len(keys))
	g, gctx := errgroup.WithContext(ctx)1
	for i, k := range keys {2
		g.Go(func() error { // fan-out: one read per source
			var err error
			parts[i], err = s.readAfter(gctx, k, cur, limit)
			return err
		})
	}
	if err := g.Wait(); err != nil {
		return nil, nil, err
	}
	page := mergeNewest(parts, limit) // fan-in: k-way merge by (score, id), dedup3
	if len(page) == 0 {
		return page, nil, nil
	}
	last := page[len(page)-1]
	return page, &Cursor{Score: last.Score, ID: last.ID}, nil
}

func (s *FeedService) readAfter(ctx context.Context, key string, cur *Cursor, limit int) ([]Entry, error) {
	max := "+inf"
	if cur != nil {
		max = strconv.FormatFloat(cur.Score, 'f', -1, 64)
	}
	zs, err := s.rdb.ZRevRangeByScoreWithScores(ctx, key, &redis.ZRangeBy{
		Max: max, Min: "-inf", Count: int64(limit + 20),4
	}).Result()
	if err != nil {
		return nil, err
	}
	out := make([]Entry, 0, limit)
	for _, z := range zs {
		e := Entry{ID: z.Member.(string), Score: z.Score}
		if cur == nil || e.Before(*cur) { // same score: smaller id only
			out = append(out, e)
		}
	}
	return out, nil
}

Mỗi pattern mở bài học tương ứng trong menu Pattern.Each one opens its lesson in the Patterns menu.