Core-Web-Hub
██████╗ ██████╗ ██████╗ ███████╗ ██╗ ██╗███████╗██████╗ ██╔════╝██╔═══██╗██╔══██╗██╔════╝ ██║ ██║██╔════╝██╔══██╗ ██║ ██║ ██║██████╔╝█████╗ ██║ █╗ ██║█████╗ ██████╔╝ ██║ ██║ ██║██╔══██╗██╔══╝ ██║███╗██║██╔══╝ ██╔══██╗ ╚██████╗╚██████╔╝██║ ██║███████╗ ╚███╔███╔╝███████╗██████╔╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═╝╚══════╝ ╚══╝╚══╝ ╚══════╝╚═════╝
Core Web
A production-ready, multi-protocol web platform built with Rust
🚀 Welcome to Core Web
Core Web is a comprehensive, production-ready web platform built with Rust that provides everything you need to build scalable, secure, and high-performance web applications. With support for multiple protocols, advanced security features, and enterprise-grade observability, Core Web is designed to handle the most demanding workloads.
██████╗ ██████╗ ██████╗ ███████╗ ██╗ ██╗███████╗██████╗
██╔════╝██╔═══██╗██╔══██╗██╔════╝ ██║ ██║██╔════╝██╔══██╗
██║ ██║ ██║██████╔╝█████╗ ██║ █╗ ██║█████╗ ██████╔╝
██║ ██║ ██║██╔══██╗██╔══╝ ██║███╗██║██╔══╝ ██╔══██╗
╚██████╗╚██████╔╝██║ ██║███████╗ ╚███╔███╔╝███████╗██████╔╝
╚═════╝ ╚═════╝ ╚═╝ ╚═╝╚══════╝ ╚══╝╚══╝ ╚══════╝╚═════╝
✨ Key Features
🌐 Multi-Protocol Support
- REST API with full CRUD operations, pagination, and ETags
- GraphQL with schema and resolvers
- gRPC with Protocol Buffer service contracts
- WebSocket/SSE for real-time communication
🗄️ Multi-Database Integration
- MySQL - Primary transactional database
- Redis - Caching, session storage, and pub/sub messaging
- MongoDB - Document storage for flexible schemas
- ClickHouse - Analytics and time-series data warehouse
🔒 Advanced Security
- Authentication: JWT, OIDC, and API key support
- Authorization: RBAC and ABAC with Casbin/Cedar
- Security Headers: HSTS, CSP, CORS/CSRF protection
- Compliance: Data protection regulation compliance
📈 Observability & Monitoring
- Distributed Tracing with OpenTelemetry
- Metrics Collection and dashboarding
- Structured Logging with multiple output formats
- Health Checks with Kubernetes-ready endpoints
⚡ Performance & Resilience
- Caching Layers: In-memory (Moka) and Redis distributed caching
- Resilience Patterns: Retry, Circuit Breaker, Bulkhead, Timeout
- Rate Limiting: Token bucket algorithm
- Idempotency: Redis-backed POST idempotency
🛠️ Developer Experience
- Auto-generated SDKs for REST and gRPC clients
- Comprehensive API Documentation
- WASM Plugin System for extensibility
- CLI Tooling for management and operations
📦 Architecture Overview
┌─────────────────────────────────────────────────────────────┐
│ Load Balancer/Proxy │
└─────────────────────┬───────────────────────────────────────┘
│
┌─────────────────────┴───────────────────────────────────────┐
│ Core Web Server (8080) │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────┐ │
│ │ REST API │ │ GraphQL │ │ gRPC │ │
│ └─────────────┘ └─────────────┘ └─────────────────────┘ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ Authentication & AuthZ │ │
│ └─────────────────────────────────────────────────────────┘ │
└─────────────────────┬───────────────────────────────────────┘
│
┌─────────────┼─────────────┐ ┌────────────┐
│ │ │ │ │
┌───────▼──┐ ┌──────▼──┐ ┌───────▼──┐ ┌──────▼──┐ ┌─────▼──────┐
│ MySQL │ │ Redis │ │ MongoDB │ │ClickHouse│ │ WASM Host │
│ (Primary)│ │(Caching)│ │(Documents)│ │(Analytics)│ │ (Plugins) │
└──────────┘ └─────────┘ └──────────┘ └──────────┘ └────────────┘
│ │ │ │ │
└─────────────┼─────────────┘ │ │
│ │ │
┌───────▼───────┐ ┌───────▼──────┐ │
│ Job Workers │ │ Events │ │
│ (Background) │ │ (Streaming) │ │
└───────────────┘ └──────────────┘ │
│ │ │
┌───────▼───────┐ ┌───────▼──────┐ │
│ Outbox Pattern│ │ Redis Streams│ │
│ Publisher │ │ Consumer │ │
└───────────────┘ └──────────────┘ │
│
┌───────▼───────┐
│ Admin Dashboard│
│ (Yew/WASM) │
└───────────────┘
🚀 Quick Start
Prerequisites
- Rust (latest stable version)
- Docker and Docker Compose
- Git
1. Clone the Repository
git clone https://github.com/your-org/core-web.git
cd core-web
2. Start Supporting Services
./scripts/dev-up.sh
3. Run the Main Web Server
cd apps/core-web
cargo run
The server will start on port 8080. Visit http://localhost:8080/healthz to verify it’s running.
🧪 Testing
Run the full test suite:
cargo test
📚 Documentation
- How to Run the Project
- Architecture Overview
- API Reference
- Feature Flags
- Crate Stack
- Framework Comparison - How Core Web compares to Axum, Rocket, and other frameworks
- Framework Roadmap - Path to becoming a modular framework
- Framework Implementation Guide - Markup signs and focus areas for framework development
- Framework Implementation Status - Current status and missing features
🛠️ CLI Tool
Core Web includes a powerful CLI tool for managing the application:
# Navigate to the CLI crate
cd crates/core-cli
# Run CLI commands
cargo run -- --help # Show help
cargo run -- start # Start the server
cargo run -- status # Check server status
cargo run -- health # Run health checks
cargo run -- logs # View logs
🛡️ Security
Core Web takes security seriously. We implement several measures to ensure the safety and integrity of our codebase:
- Automated Security Scanning: CodeQL analysis runs on every push and pull request
- Dependency Monitoring: Dependabot keeps dependencies up-to-date and alerts on vulnerabilities
- Security Audits: Regular cargo-audit scans for known vulnerabilities in dependencies
- Secure Coding Practices: Following Rust community guidelines for secure development
- Branch Protection: Main branch is protected with required status checks and code reviews
- GitHub Rulesets: Enhanced policy enforcement for commits and file modifications
For security-related issues, please see our Security Policy.
📈 Performance
Core Web is optimized for high performance:
- Built with async Rust for maximum efficiency
- Zero-copy serialization with Serde
- Connection pooling for database access
- Efficient caching strategies
- HTTP/2 and HTTP/3 support
🤝 Contributing
We welcome contributions! Please see our Contributing Guide for details on how to get started.
- Fork the repository
- Create your feature branch (
git checkout -b feature/amazing-feature) - Commit your changes (
git commit -m 'Add some amazing feature') - Push to the branch (
git push origin feature/amazing-feature) - Open a pull request
Please also read our Code of Conduct before contributing.
📄 License
This project is licensed under the MIT License - see the LICENSE file for details.
🙏 Acknowledgments
- Built with Rust
- Powered by Axum web framework
- Database access with SQLx
- Observability with OpenTelemetry
- Containerization with Docker
📞 Support
For support, please open an issue on GitHub.
Project Maintainers:
- Seng Keat
- Jonathan Seng
🚀 Scaling Up
Core Web is designed with scalability in mind. The architecture supports horizontal scaling through:
- Microservices Pattern: Independent services that can be scaled separately
- Load Balancing: Distribute traffic across multiple instances
- Database Sharding: Horizontal partitioning of data across multiple databases
- Caching Layers: Redis clustering for distributed caching
- Containerization: Docker support for easy deployment and scaling
- Kubernetes Ready: Deployment manifests included for orchestration
To scale the application:
- Vertical Scaling: Increase resources (CPU, RAM) for existing instances
- Horizontal Scaling: Add more instances behind a load balancer
- Database Scaling: Implement read replicas and sharding strategies
- Caching: Expand Redis cluster for better performance
- Background Jobs: Scale job workers independently based on workload
For production deployments, consider using the provided Kubernetes manifests in the k8s/ directory to orchestrate scaling automatically based on metrics and resource usage.
Made with ❤️ and 🦀 Rust