> ## Documentation Index
> Fetch the complete documentation index at: https://upstash.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Build a Real-Time Chat Application with Serverless Redis
In this tutorial, we will build a real-time chat application using Flask and SocketIO, leveraging Upstash Redis for efficient message handling. Redis, being a fast, in-memory data store, provides an ideal backbone for real-time messaging systems due to its low latency and support for Pub/Sub messaging patterns.
## Why Upstash Redis?
* **Scalability:** Handles large volumes of messages with minimal latency.
* **Simplicity:** Easy to set up with minimal configuration.
* **Cost-Efficiency:** Serverless model reduces operational costs.
***
## **Setup**
### **1. Install the Required Libraries**
Install Flask, Flask-SocketIO, and the Redis library by running:
```bash theme={"system"}
pip install flask flask-socketio redis
```
### **2. Create a Redis Database**
Create a Redis database using the [Upstash Console](https://console.upstash.com) or [Upstash CLI](https://github.com/upstash/cli).
Create a `.env` file in the root of your project with the following content:
```bash theme={"system"}
UPSTASH_REDIS_HOST=your_upstash_redis_host
UPSTASH_REDIS_PORT=your_upstash_redis_port
UPSTASH_REDIS_PASSWORD=your_upstash_redis_password
```
## **Code**
Now, it's time to implement the chat application. We'll create a Flask server that uses SocketIO for real-time communication. We'll also configure the server to use Upstash Redis as the message queue.
We need to use the `rediss://` protocol instead of `redis://` to connect to Redis over TLS. This ensures secure communication between the server and the Redis instance.
```python main.py theme={"system"}
from flask import Flask, render_template
from flask_socketio import SocketIO
import os
# Initialize Flask app
app = Flask(__name__)
app.config["SECRET_KEY"] = os.getenv("SECRET_KEY", os.urandom(24))
# Set up Redis URL with TLS
redis_password = os.getenv('UPSTASH_REDIS_PASSWORD')
redis_host = os.getenv('UPSTASH_REDIS_HOST')
redis_port = int(os.getenv('UPSTASH_REDIS_PORT', 6379))
redis_url = f"rediss://:{redis_password}@{redis_host}:{redis_port}"
# Initialize SocketIO with Redis message queue
socketio = SocketIO(app, message_queue=redis_url, cors_allowed_origins="*")
# WebSocket handlers
@socketio.on("connect")
def handle_connect():
print("Client connected.")
@socketio.on("disconnect")
def handle_disconnect():
print("Client disconnected.")
@socketio.on("message")
def handle_message(data):
"""Handle incoming chat messages."""
print(f"Message received: {data}")
# Broadcast the message to all connected clients except the sender
socketio.emit("message", data, include_self=False)
# Serve the chat HTML page
@app.route("/")
def index():
return render_template("chat.html") # Render the chat interface template
if __name__ == "__main__":
socketio.run(app, debug=True, host="0.0.0.0", port=8000)
```
### **Code Explanation**
* We initialized a Flask app and set a secret key for session management.
* We set up the Redis URL with TLS for secure communication.
* We initialize a SocketIO instance with the Flask app and configure it to use Redis as the message queue.
* We define WebSocket event handlers for `connect`, `disconnect`, and `message` events.
* The `handle_message` function broadcasts the received message to all connected clients except the sender.
* We define a route to serve the chat interface template.
Now let's create a template for the chat interface. We're not going to go into the details of the HTML and CSS, as the focus is on the real-time messaging functionality.
```html chat.html theme={"system"}
Real-Time Chat
```
***
### **Running the Application**
1. Start the server:
```bash theme={"system"}
python app.py
```
2. Open your web browser and go to `http://localhost:8000/`.
You should see the chat interface. You can send and recieve messages in real-time. Just open the same URL in multiple tabs or browsers to simulate multiple users chatting with each other.
***
## **Conclusion**
In this tutorial, we built a real-time chat application using Flask, SocketIO, and Upstash Redis. Redis, with its low latency and high throughput, is an ideal choice for real-time messaging systems.
To learn more about Upstash Redis, visit the [Upstash Redis Documentation](/redis).