Scalable Chat Platform

A production-ready, cloud-native chat platform built on AWS demonstrating enterprise-level scalability and DevOps practices.

Architecture Overview

This platform implements a microservices architecture with the following components:

• Authentication Service: JWT-based authentication with session management
• Message Router: Message routing and room management
• WebSocket Handler: Real-time WebSocket connections with goroutines
• Message Persistence: PostgreSQL-based message storage
• User Presence: Online/offline status tracking

Key Features

• ✅ Scalability: Supports >1000 concurrent connections
• ✅ Performance: P95 response time <100ms
• ✅ Reliability: 99.9% uptime with auto-scaling
• ✅ Real-time: WebSocket-based messaging
• ✅ Monitoring: CloudWatch integration with custom metrics
• ✅ Security: JWT authentication, TLS encryption
• ✅ DevOps: GitHub Actions CI/CD with blue-green deployment

Quick Start

Prerequisites

• Go 1.21+
• Docker & Docker Compose
• AWS CLI configured
• Terraform (for infrastructure)

Local Development

1. Clone and setup:

   git clone <repository>
   cd Scalable-Chat-Platform
   cp .env.example .env

2. Start local services:

   docker-compose up -d postgres redis

3. Run database migrations:

   make migrate-up

4. Start services:

   make run-all

AWS Deployment

1. Deploy infrastructure:

   cd infrastructure
   terraform init
   terraform plan
   terraform apply

2. Build and push containers:

   make build-all
   make push-all

3. Deploy services:

   make deploy-all

Service Architecture

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   Auth Service  │    │ Message Router  │    │ WebSocket Handler│
│   Port: 8080    │    │   Port: 8081    │    │   Port: 8082    │
└─────────────────┘    └─────────────────┘    └─────────────────┘
         │                       │                       │
         └───────────────────────┼───────────────────────┘
                                 │
                    ┌─────────────────┐    ┌─────────────────┐
                    │ Message Persist │    │ Presence Service│
                    │   Port: 8083    │    │   Port: 8084    │
                    └─────────────────┘    └─────────────────┘

API Endpoints

Authentication Service (8080)

• POST /auth/register - User registration
• POST /auth/login - User login
• POST /auth/refresh - Token refresh
• GET /auth/validate - Token validation

Message Router (8081)

• GET /rooms - List chat rooms
• POST /rooms - Create room
• POST /rooms/:id/join - Join room
• GET /rooms/:id/messages - Get messages

WebSocket Handler (8082)

• WS /ws - WebSocket connection
• Real-time message broadcasting
• Connection management

Message Persistence (8083)

• POST /messages - Store message
• GET /messages/search - Search messages
• GET /messages/:id - Get message

Presence Service (8084)

• GET /presence/:user_id - Get user status
• POST /presence/heartbeat - Update presence

Monitoring

Custom Metrics

• websocket_connections_active - Active WebSocket connections
• messages_per_second - Message throughput
• auth_success_rate - Authentication success rate
• response_time_p95 - 95th percentile response time

Health Checks

• /health - Service health status
• /ready - Service readiness
• /metrics - Prometheus metrics

Development

Project Structure

├── cmd/                    # Service entry points
│   ├── auth-service/
│   ├── message-router/
│   ├── websocket-handler/
│   ├── message-persistence/
│   └── presence-service/
├── internal/               # Private application code
│   ├── auth/
│   ├── messaging/
│   ├── websocket/
│   ├── persistence/
│   └── presence/
├── pkg/                    # Public packages
│   ├── config/
│   ├── database/
│   ├── redis/
│   ├── monitoring/
│   └── utils/
├── infrastructure/         # Terraform/CDK code
├── deployments/           # Kubernetes/ECS configs
├── scripts/               # Build and deployment scripts
└── docs/                  # Documentation

Testing

make test              # Run all tests
make test-coverage     # Run tests with coverage
make test-integration  # Run integration tests

Building

make build-all         # Build all services
make build-auth        # Build specific service
make docker-build      # Build Docker images

Performance Benchmarks

• Concurrent Connections: 1000+ per instance
• Message Throughput: 10,000+ messages/second
• Response Time: P95 <100ms, P99 <200ms
• Memory Usage: <512MB per service instance
• CPU Usage: <70% under normal load

Security

• JWT token authentication with refresh tokens
• TLS 1.3 encryption for all communications
• Rate limiting and DDoS protection
• Input validation and sanitization
• Secrets management via AWS Secrets Manager

Contributing

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Add tests
5. Submit a pull request

License

MIT License - see LICENSE file for details