A real-time chat backend written in Go, using WebSockets for live messaging, PostgreSQL for persistent storage, and Redis for pub/sub.

git clone https://github.com/vit0rr/chat.git
cd chat

A docker-compose.yaml is provided to spin up the local dependencies:

podman compose up -d   # or: docker compose up -d

Rootless Podman note: the compose provider needs Podman's user API socket running. Enable it once with systemctl --user enable --now podman.socket.

This starts:

• PostgreSQL on port 5432 (database db_chat, user/password docker/docker)
• Redis on port 6379

1. Install dependencies:

go mod tidy

2. Set up environment variables:

cp .env.example .env

3. Run the server:

go run cmd/api/main.go

For a clean local slate, drop the data volume and let the schema re-apply on the next boot:

podman compose down -v   # or: docker compose down -v — drops the Postgres volume
podman compose up -d

This project uses Swagger to document the API. The code generation was made using Swag. After updating the documentation — by adding/editing comments in the code — you can regenerate it with:

swag init -d ./cmd/api/,./

This updates the docs folder. Access the docs by running the project and opening http://localhost:8080/swagger/index.html.

A k6 WebSocket load test lives in test/load/chat.js. It drives many concurrent clients through the real connection flow — register → join room → WebSocket → send — to stress the server, PostgreSQL, and Redis together.

With the dependencies and server running:

k6 run test/load/chat.js
# scale up:
k6 run -e USERS=500 -e ROOMS=50 -e DURATION=120s test/load/chat.js

Custom metrics reported at the end:

• chat_msgs_sent / chat_msgs_received — throughput counters.
• chat_round_trip — publish→receive latency (ms); threshold p95 < 2000ms.
• chat_rate_limited — count of "Please wait…" replies. If high, raise SEND_INTERVAL — you're hitting the 1.5s/user server limit.
• ws_connecting — WebSocket handshake time.
• checks — share of successful 101 handshakes (threshold > 95%).

• Per-user rate limit is 1.5s: one user can't flood — scale USERS, not the send rate, to push throughput.
• Postgres is in the hot path: every message is written to Postgres and published to Redis, so this also load-tests the database.
• For thousands of sockets, raise ulimit -n on the machine running the server.
• Each user registers a unique email; reruns create new users. Wipe with podman compose down -v (drops the data volumes) for a clean slate.

All environment variables needed to run this project are listed in .env.example. Create your .env from it:

cp .env.example .env

This project is licensed under the MIT License - see the LICENSE file for details.