Computer >> Hướng Dẫn Máy Tính >  >> Lập Trình >> Redis

Xây Dựng Real-Time Chat App Với Upstash Kafka, Redis Và Next.js

Mô Tả Dự Án

Trong bài viết này, tạo messaging application cho phép user tạo message client và chat room. Ngoài ra, user truy cập tin nhắn quá khứ.

Dự án gồm hai page. Page đầu dedicated cho client registration, tạo multiple client với tên unique.

Xây Dựng Real-Time Chat App Với Upstash Kafka, Redis Và Next.js

Khi click username client, điều hướng đến chatroom client liên kết với user cụ thể.

Xây Dựng Real-Time Chat App Với Upstash Kafka, Redis Và Next.js

Logic chat application:

User tạo multiple client trên index page, mỗi client username unique. Click username client mở tab mới với client riêng path unique.

Mỗi client kết nối message server qua WebSocket connection. Khi message mới tạo trên client, gửi đến message server liên kết client đó.

Message server handle message traffic. Khi client gửi message qua WebSocket, server direct đến Kafka Broker. Mỗi message server chạy NodeJS thread handle incoming message. Khi message consumed, gửi đến client qua WebSocket connection hiện có. Để consume incoming message client-side, dùng library react-use-websocket.

Ứng dụng dùng Upstash Redis lưu message history. Khi message produced đến Kafka, cũng persist vào Redis database. Khi tạo client mới, tin nhắn cũ lấy từ Upstash Redis render trong chat display.

Tổng quan ứng dụng:

Lưu ý: Implementation tạo single message server cho demo, có thể tăng số server handle message load.

Xây Dựng Real-Time Chat App Với Upstash Kafka, Redis Và Next.js

Demo

Demo app tại đây. Phiên bản hiện tại deploy lên Fly.

Bắt Đầu

Các bước xây dựng chat application:

  1. Tạo Upstash Redis database
  2. Tạo Upstash Kafka cluster
  3. Tạo Next application (frontend).
  4. Tạo WebSocket message server.
  5. Deploy ứng dụng lên Fly.io

Tạo Upstash Redis Database

Điều hướng Upstash Console login, tab Redis, nhấn Create Database.

Xây Dựng Real-Time Chat App Với Upstash Kafka, Redis Và Next.js

Redis ready! Quay lại Redis console lấy credentials.

Tạo Upstash Kafka Cluster

Chuyển tab Kafka, nhấn Create Cluster. Nhập cluster name tiến hành. Tạo Kafka topic confirm.

Xây Dựng Real-Time Chat App Với Upstash Kafka, Redis Và Next.js

Tạo Next App

Trước tiên, tạo và điều hướng root folder ứng dụng từ terminal. Giữ Next app và server trong folder này.

mkdir chat-app
cd chat-app

Tạo next app.

$ npx create-next-app@latest
✔ What is your project named? … next-chat-app
✔ Would you like to use TypeScript? … Yes
✔ Would you like to use ESLint? … Yes
✔ Would you like to use Tailwind CSS? … No
✔ Would you like to use `src/` directory? … No
✔ Would you like to use App Router? (recommended) … No
✔ Would you like to customize the default import alias? … No

Xử Lý Credentials

Tạo file .env lưu credentials. Không cần copy paste credentials lại lại, import từ file này.

Tạo file .env.

Điều hướng Redis console, copy/paste UPSTASH_REDIS_REST_URL và UPSTASH_REDIS_REST_TOKEN vào .env.

Xây Dựng Real-Time Chat App Với Upstash Kafka, Redis Và Next.js

Chuyển Kafka console, chuyển UPSTASH_KAFKA_REST_URL, UPSTASH_KAFKA_REST_USERNAME, UPSTASH_KAFKA_REST_PASSWORD

Xây Dựng Real-Time Chat App Với Upstash Kafka, Redis Và Next.js

File .env trông như:

UPSTASH_REDIS_REST_URL=...
UPSTASH_REDIS_REST_TOKEN=...
UPSTASH_KAFKA_REST_URL=...
UPSTASH_KAFKA_REST_USERNAME=...
UPSTASH_KAFKA_REST_PASSWORD=...

Credentials configured, tiến hành ứng dụng.

Client Registration Page

Index page chứa client registration/creation. Khi submit username, client mới tạo list dưới bảng Current Clients.

import { useState } from "react";
import Link from "next/link";
import { Redis } from "@upstash/redis";
import styles from "@/styles/Home.module.css";
export default function Home() {
  const [usernameInput, setUsernameInput] = useState<string>("");
  const [usernameList, setUsernameList] = useState<string[]>(Array<string>);
  const handleInputChange = (e: React.ChangeEvent<HTMLInputElement>): void => {
    const inputValue: string = e.target.value;
    setUsernameInput(inputValue);
  };
  const addUsernameClient = (e: React.FormEvent<HTMLFormElement>): void => {
    e.preventDefault();
    setUsernameList([...usernameList, usernameInput]);
    setUsernameInput("");
  };
  return (
    <div className={styles.container}>
      <div className={styles.welcomeSection}>
        <h1>Welcome to the demo message app!</h1>
        <p>
          This application uses Upstash Kafka for message passing, and Upstash Redis for state management.
          <br />
          <br />
          To get started, create several clients by typing in unique usernames to the input section below and submitting.
          <br />
          <br />
          The usernames will be added to the list of current clients. Click on a username to open a new tab with that client&apos;s message display.
          <br />
          <br />
          You can have multiple sessions open at once.
        </p>
      </div>
      <form className={styles.formSection} onSubmit={addUsernameClient}>
        <input type="text" className={styles.formInput} value={usernameInput} onChange={handleInputChange} ></input>
        <button className={styles.formSubmit} type="submit"> Create the client! </button>
      </form>
      <div className={styles.clientListSection}>
        <p className={styles.clientListHeader}>Current Clients</p>
        <div className={styles.clientList}>
          {usernameList.map((username, i) => {
            return (
              <Link href={`/user/${username}`} key={`${i}`} className={styles.userClient} target={"_blank"} >
                <p>{username}</p>
              </Link>
            );
          })}
        </div>
      </div>
    </div>
  );
}

Nếu muốn reset chat history mỗi lần reload app, dùng function:

export async function getServerSideProps() {
  const redis = new Redis({
    url: process.env.UPSTASH_REDIS_REST_URL,
    token: process.env.UPSTASH_REDIS_REST_TOKEN,
  });
  await redis.del("messagesList");
  return { props: {}, };
}

Index page ready. Chạy npm run dev trong folder next-chat-app xem index page live.

Message Client Page

Triển khai dynamic routing cho client, tạo folder /pages/user/[username].tsx. Cấu trúc folder cho phép tạo dynamic route cho mỗi client dựa trên username.

Main component client. Component hold state cho message list, username v.v. Dùng hook useWebSocket tạo message, connection và disconnection events từ WebSocket. Khi message event emitted, message thêm vào message list và MessageDisplay component rerender.

import { useState } from "react";
import { useRouter } from "next/router";
import { Redis } from "@upstash/redis";
import useWebSocket from "react-use-websocket";
import styles from "@/styles/Home.module.css";
type Message = {
  id: number;
  sender: string;
  text: string;
};
export default function MessageApp(props: { messagesData: Message[] }) {
  const { messagesData } = props;
  const { username } = useRouter().query;
  const [inputText, setInputText] = useState<string>("");
  const [messageList, setMessageList] = useState<Message[]>(messagesData);
  const [messageCounter, setMessageCounter] = useState<number>(0);
  const handleMessage = function (message: Message) {
    const nextMessages = [...messageList, message];
    setMessageList(nextMessages);
  };
  // handling WebSocket events
  const { sendMessage } = useWebSocket("ws://localhost:8080", {
    share: true,
    filter: () => false,
    onOpen: () => {
      console.log("WebSocket connection!");
      return "connection";
    },
    onMessage: (message) => {
      const data = JSON.parse(message.data);
      const { sender, text }: { sender: string; text: string } = data;
      const messageData: Message = {
        id: messageCounter,
        sender: sender,
        text: text,
      };
      setMessageCounter(messageCounter + 1);
      handleMessage(messageData);
      return message;
    },
    onClose: () => {
      console.log("WebSocket disconnected!");
      return "disconnected";
    },
  });
  function handleSendMessage(messageText: string) {
    const messageData = {
      sender: username,
      text: messageText,
    };
    sendMessage(JSON.stringify(messageData));
  }
  return (
    <div className={styles.Container}>
      <MessageDisplay messages={messageList} />
      <MessageInput inputText={inputText} setInputText={setInputText} handleSendMessage={handleSendMessage} />
    </div>
  );
}

MessageDisplay và MessageInput components:

const MessageDisplay = function (props: { messages: Message[] }) {
  const { messages } = props;
  return (
    <div className={styles.messageContainer}>
      {messages.map((message) => (
        <MessageBubble key={message.id} sender={message.sender} text={message.text} />
      ))}
    </div>
  );
};
const MessageInput = (props: { inputText: string; setInputText: (msg: string) => void; handleSendMessage: (msg: string) => void; }) => {
  const { inputText, setInputText, handleSendMessage } = props;
  const handleInputChange = (e: React.ChangeEvent<HTMLInputElement>): void => {
    const inputValue: string = e.target.value;
    setInputText(inputValue);
  };
  const handleSubmit = (e: React.FormEvent<HTMLFormElement>): void => {
    e.preventDefault();
    handleSendMessage(inputText);
    if (inputText.trim() !== "") {
      setInputText(" ");
    }
  };
  return (
    <form className={styles.inputSection} onSubmit={handleSubmit}>
      <input className={styles.inputText} type="text" value={inputText} onChange={handleInputChange} ></input>
      <button className={styles.inputSendButton} type="submit"> Send </button>
    </form>
  );
};
const MessageBubble = (props: { sender: string; text: string; key: number; }) => {
  const { sender, text } = props;
  const { username } = useRouter().query;
  const isSender = sender === username;
  const senderClass = isSender ? "sender" : "receiver";
  return (
    <div className={`${styles["messageBubble"]} ${styles[senderClass]}`}>
      <div className={styles.messageSender}>
        {isSender ? "You" : sender}
      </div>
      <div className={styles.messageText}>{text}</div>
    </div>
  );
};

Cung cấp chat history cho client, dùng getServerSideProps() function.

export async function getServerSideProps() {
  const redis = new Redis({
    url: process.env.UPSTASH_REDIS_REST_URL,
    token: process.env.UPSTASH_REDIS_REST_TOKEN,
  });
  const messagesData = (await redis.lrange("messagesList", 0, -1)).reverse();
  return { props: { messagesData, }, };
}

Next.js app giờ working. Refresh page, tạo client và navigate một trong số đó. Bạn thấy client page. Nhưng vẫn cần message server handle message flow.

Tạo Message Server

Cấu trúc server đơn giản. Dùng Node.js, ws library, Upstash Kafka. Trước tiên, tạo folder server trong chat-app folder.

mkdir server
cd server

Trong folder server, cài requirements config files.

npm install typescript ws tsc @upstash/kafka @types/ws tsc --init

Tạo WebSocket, Kafka Producer và Kafka Consumer clients trong /server/message_server.ts:

import * as http from "http";
import { Kafka } from "@upstash/kafka";
import { Redis } from "@upstash/redis";
import { WebSocket } from "ws";
const server = http.createServer();
const wss = new WebSocket.Server({ server });
server.listen(8080, () => {
  console.log("Server is running on port 8080");
});
const kafka = new Kafka({
  url: process.env.UPSTASH_KAFKA_REST_URL,
  username: process.env.UPSTASH_KAFKA_REST_USERNAME,
  password: process.env.UPSTASH_KAFKA_REST_PASSWORD,
});
const redis = new Redis({
  url: process.env.UPSTASH_REDIS_REST_URL,
  token: process.env.UPSTASH_REDIS_REST_TOKEN,
});
const consumer = kafka.consumer();
const producer = kafka.producer();
const clients = new Set<WebSocket>();

Tương tác WebSocket, tạo event connection và message.

wss.on("connection", async (connection, req) => {
  clients.add(connection);
  console.log(`New client connected!`);
  connection.on("message", async (message) => {
    const jsonMessage = message.toString();
    console.log("Received message:", JSON.parse(jsonMessage));
    producer.produce("chat", jsonMessage);
  });
  connection.on("close", () => {
    console.log(`Client disconnected:`);
    clients.delete(connection);
  });
});

Cuối, tạo và chạy thread consume message với interval định sẵn:

async function run() {
  while (true) {
    const messages = await consumer.consume({
      consumerGroupId: "group_1",
      instanceId: "instance_1",
      topics: ["chat"],
      autoOffsetReset: "earliest",
    });
    if (messages.length != 0) {
      for (let i = 0; i < messages.length; i++) {
        await redis.lpush("messagesList", messages[i].value);
        console.log(`Message sending: ${messages[i].value}`);
        clients.forEach((connection: WebSocket) => {
          connection.send(messages[i].value);
        });
      }
    }
    console.log("Run!");
    await new Promise((resolve) => setTimeout(resolve, 1000));
  }
}

Mọi thứ ready. App nên work như charm. Chạy message server local refresh client page, thấy message truyền giữa client. Commands dưới transcompile TS file chạy server localhost:8000

tsc message_server.ts
node message_server.js

Deployment

Dùng Fly.io deploy. Tạo account trước nếu chưa có.

Deploy Message Server

Vào folder server cài flyctl CLI tool, authorize via shell

npm install flyctl
flyctl auth login

Tạo config files, chạy flyctl init. Tạo fly.toml. Vào fly.toml thêm dòng sau cho WebSocket connection config:

[[services]]
internal_port = 8080
protocol = "tcp"
[services.concurrency]
hard_limit = 25
soft_limit = 20
[[services.ports]]
handlers = ["http"]
port = "80"
[[services.ports]]
handlers = ["tls", "http"]
port = "443"
[[services.tcp_checks]]
interval = 10000
timeout = 2000

Bước cuối server. Chạy flyctl deploy, ready! Khi deploy xong, flyctl cung cấp endpoint server. Copy endpoint. Trong case này, endpoint message-server.fly.dev.

Deploy Next Application

Trước deploy Next.js app, nhúng deployment endpoint message server. Thay WebSocket URL trong pages/user/[username].tsx từ ws://localhost:8080 thành endpoint từ flyctl kết hợp prefix wss://. Case này wss://message-server.fly.dev.

Sau đó, trong folder next-chat-app, chạy commands giống server. Lần này không edit fly.toml, tiến hành không bước đó.

flyctl init
flyctl deploy 

Xong! Chạy flyctl open navigate đến deployed project.

Kết Luận Và Đề Xuất

Cảm ơn bạn đã follow along!

GitHub repository dự án tại đây.

Muốn tiếp tục dự án, đề xuất:

  • Hiện tại, mỗi lần reload page, tất cả stored messages trong Upstash Redis bị flush. Hành vi này controlled bởi code trong pages/index.tsx, cụ thể trong function getServerSideProps. Tuy nhiên, critical issue nảy sinh khi user reload page, dẫn đến xóa chat history cho tất cả participant trong chatroom.
    Giải pháp khuyến nghị: implement extension của TTL cho chat history mỗi lần message gửi. Cải tiến này đảm bảo chat history accessible và preserved kể cả sau page reload.

  • Triển khai multiple chatrooms feature. Tạo multiple Kafka topic tên unique cho mỗi chatroom. Cách khác handle trên message server dùng đúng data structures.

  • Triển khai multiple message servers, và load balancer áp dụng best system design practices.

Nếu có câu hỏi, liên hệ fahreddin@upstash.com