https://github.com/pedrosfaria2/api-gateway
A high-performance API Gateway written in Go, following Clean Architecture principles. Features dynamic routing, middleware support, and plugin system for extensibility. Built for reliability and ease of use in modern microservices architectures.
https://github.com/pedrosfaria2/api-gateway
api-gateway api-management authentication circuit-breaker clean-architecture distributed-systems golang high-performance jwt jwt-authentication load-balancer metrics microservices middleware monitoring rate-limiting reverse-proxy service-discovery
Last synced: about 1 year ago
JSON representation
A high-performance API Gateway written in Go, following Clean Architecture principles. Features dynamic routing, middleware support, and plugin system for extensibility. Built for reliability and ease of use in modern microservices architectures.
- Host: GitHub
- URL: https://github.com/pedrosfaria2/api-gateway
- Owner: pedrosfaria2
- License: mit
- Created: 2024-11-27T22:51:55.000Z (over 1 year ago)
- Default Branch: main
- Last Pushed: 2024-11-28T00:40:39.000Z (over 1 year ago)
- Last Synced: 2025-02-09T20:29:10.596Z (over 1 year ago)
- Topics: api-gateway, api-management, authentication, circuit-breaker, clean-architecture, distributed-systems, golang, high-performance, jwt, jwt-authentication, load-balancer, metrics, microservices, middleware, monitoring, rate-limiting, reverse-proxy, service-discovery
- Language: Go
- Homepage:
- Size: 15.6 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# API Gateway
A modern, high-performance API Gateway built with Go, designed with Clean Architecture principles. This project aims to provide a flexible, modular, and extensible solution for API management and routing.
## Key Features
- **Clean Architecture**: Clear separation of concerns with a layered architecture
- **Dynamic Configuration**: Easy configuration via YAML/JSON without requiring recompilation
- **High Performance**: Built for high concurrency and low latency
- **Extensible Plugin System**: Easy to add new middlewares and functionalities
- **Monitoring & Metrics**: Built-in support for metrics and monitoring
- **Modern Development**: Docker support, hot-reloading, and comprehensive testing
## Architecture
The project follows Clean Architecture principles with distinct layers:
- **Core**: Contains the central business logic and domain rules
- **Infrastructure**: Implements external tool integrations
- **Plugins**: Modular system for extending functionality
- **Configuration**: Manages system settings and routing rules
## Quick Start
### Prerequisites
- Go 1.21 or higher
- Docker and Docker Compose
- Make
### Development Setup
1. Install dependencies:
```bash
make install-deps
make setup
make setup-hooks
```
2. Run locally:
```bash
make run-dev # Run with hot-reload
# or
make run # Run without hot-reload
```
3. Run with Docker:
```bash
make run-docker
# or
make run-compose # Run with Docker Compose
```
## Testing
```bash
make test # Run tests
make test-coverage # Run tests with coverage
```
## Code Quality
```bash
make lint # Run linters
make format # Format code
```
## Project Goals
1. **Extensibility**: Easy addition of new middlewares and backends without core changes
2. **Modularity**: Clear separation of concerns and responsibilities
3. **Performance**: Optimized for high throughput and low latency
4. **Developer Experience**: Simple configuration and deployment
5. **Reliability**: Comprehensive testing and monitoring
## Core Components
- Dynamic routing with configurable backends
- Middleware chain for request/response processing
- Plugin system for authentication, caching, and more
- Metrics and monitoring integration
- Request/response transformation capabilities
- Rate limiting and circuit breaking