Merancang Backend Obrolan Waktu Nyata dengan gRPC
Ikuti studi kasus nyata tentang perancangan backend obrolan waktu nyata yang dapat diskalakan menggunakan streaming dua arah gRPC, fan-out, dan kehadiran.
Merancang Backend Obrolan Waktu Nyata dengan gRPC adalah pelajaran gRPC & High Performance APIs gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar gRPC & High Performance APIs, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus gRPC & High Performance APIs mencakup 4 pelajaran total.
Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.
The Case Study
We design a chat backend that must deliver messages instantly to thousands of connected users. gRPC bidirectional streaming is a natural fit for this long-lived, two-way flow.
Defining the Service
The core is a bidi stream: clients send messages and receive others' messages over the same call.
service Chat {
rpc Connect(stream ClientEvent) returns (stream ServerEvent);
}Per-Connection Sessions
Each open stream is a user session. The server tracks the stream handle so it can push messages to that specific user later.
The Fan-Out Problem
When one user posts to a room, the server must deliver it to every other member's stream. This fan-out is the heart of chat scaling.
In-Process Hub
A simple design keeps a hub mapping rooms to subscriber channels. Posting iterates members and sends to each.
func (h *Hub) Broadcast(room string, msg *ServerEvent) {
for _, sub := range h.rooms[room] {
sub.outbox <- msg
}
}Scaling Past One Instance
Users on different server instances must still see each other. Introduce a message bus (Redis Pub/Sub, NATS, Kafka) so instances relay messages to one another.
Cross-Instance Flow
An instance publishes new messages to the bus; every instance subscribes and forwards to its own local connections. This decouples delivery from where users connect.
Presence and Typing
Presence (online/offline) and typing indicators are just more event types on the stream. Track last-seen timestamps and broadcast presence changes via the same fan-out path.
Backpressure per Client
A slow client must not stall the hub. Give each session a bounded outbox; if it overflows, drop or disconnect that client instead of blocking everyone.
select {
case sub.outbox <- msg:
default:
disconnect(sub) // slow consumer
}Reconnection and Delivery
Networks drop. Clients reconnect and resume from a last-seen message id. Persist recent history so missed messages can be replayed on reconnect.
Operational Concerns
Production chat needs:
- Keepalive to detect dead connections
- Authentication on connect (token in metadata)
- Metrics on active streams and fan-out latency
- Graceful drain on deploy
Quick Check
Test your chat-design knowledge.
Recap
You designed a real-time chat backend:
- Bidirectional streaming models each user session
- A hub fans out room messages to subscribers
- A message bus relays across multiple instances
- Presence/typing are extra event types; per-client backpressure protects the hub
- Reconnection replays missed messages; ops needs keepalive, auth, metrics, drain
Belajar gRPC & High Performance APIs dengan tutor AI — gratis
Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.
- Kursus
- 12
- Pelajaran
- 48
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Merancang Backend Obrolan Waktu Nyata dengan gRPC” gratis?
Ya — teks lengkap “Merancang Backend Obrolan Waktu Nyata dengan gRPC” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus gRPC & High Performance APIs, upgrade ke CoddyKit PRO. Kursus gRPC & High Performance APIs mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Merancang Backend Obrolan Waktu Nyata dengan gRPC”?
Ikuti studi kasus nyata tentang perancangan backend obrolan waktu nyata yang dapat diskalakan menggunakan streaming dua arah gRPC, fan-out, dan kehadiran. Kamu berlatih gRPC & High Performance APIs dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai gRPC & High Performance APIs?
Tidak diperlukan pengalaman sebelumnya. gRPC & High Performance APIs di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.
Berapa lama pelajaran “Merancang Backend Obrolan Waktu Nyata dengan gRPC” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran gRPC & High Performance APIs ini?
Ya. Setiap pelajaran gRPC & High Performance APIs menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- Membangun Gateway Throughput Tinggi
- Pola Ketahanan Tingkat Lanjut
- Masa Depan API Berperforma Tinggi
- Merancang Backend Obrolan Waktu Nyata dengan gRPC