Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/dev-mohitbeniwal/echo
Echo is an open-source attribute-based access control (ABAC) system in Go. It offers fine-grained access control, high-performance policy evaluation with Neo4j, real-time updates, comprehensive auditing, caching, event-driven architecture, and a RESTful API. Docker support included.
https://github.com/dev-mohitbeniwal/echo
abac access-control attribute-based-access-control auditing authorization caching golang neo4j open-source security
Last synced: 3 months ago
JSON representation
Echo is an open-source attribute-based access control (ABAC) system in Go. It offers fine-grained access control, high-performance policy evaluation with Neo4j, real-time updates, comprehensive auditing, caching, event-driven architecture, and a RESTful API. Docker support included.
- Host: GitHub
- URL: https://github.com/dev-mohitbeniwal/echo
- Owner: dev-mohitbeniwal
- Created: 2024-07-06T17:33:55.000Z (6 months ago)
- Default Branch: main
- Last Pushed: 2024-08-07T20:41:34.000Z (5 months ago)
- Last Synced: 2024-09-27T21:41:32.365Z (4 months ago)
- Topics: abac, access-control, attribute-based-access-control, auditing, authorization, caching, golang, neo4j, open-source, security
- Language: Go
- Homepage:
- Size: 15.5 MB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# Echo - Attribute-Based Access Control (ABAC) System
Echo is a robust, scalable Attribute-Based Access Control (ABAC) system designed to provide fine-grained access control for modern applications. It offers a flexible policy management system, high-performance policy evaluation, and comprehensive auditing capabilities.
## Features
- **Fine-grained Access Control**: Implement complex access control policies based on user attributes, resource attributes, and environmental conditions.
- **High-Performance Policy Evaluation**: Utilizes Neo4j for efficient policy storage and evaluation.
- **Scalable Architecture**: Built with Go and designed to handle high loads.
- **Real-time Policy Updates**: Policies can be updated in real-time without system downtime.
- **Comprehensive Auditing**: All access decisions are logged and can be analyzed for security and compliance purposes.
- **Caching**: Redis-based caching for improved performance.
- **Event-Driven Architecture**: Utilizes an event bus for asynchronous processing of policy changes and notifications.
- **RESTful API**: Easy integration with existing systems through a well-defined API.
- **Containerized Deployment**: Docker and Docker Compose support for easy deployment and scaling.
## Technology Stack
- **Backend**: Go (Gin web framework)
- **Database**: Neo4j (for policy storage and evaluation)
- **Cache**: Redis
- **Search and Audit Log**: Elasticsearch
- **Frontend**: React with Next.js (work in progress)
- **Containerization**: Docker and Docker Compose
## Project Structure
```bash
.
├── README.md
├── api/ # Backend Go application
│ ├── audit/ # Audit logging functionality
│ ├── config/ # Configuration management
│ ├── controller/ # HTTP request handlers
│ ├── dao/ # Data Access Objects
│ ├── db/ # Database connection management
│ ├── logging/ # Logging utilities
│ ├── middleware/ # HTTP middleware
│ ├── model/ # Data models
│ ├── service/ # Business logic
│ └── util/ # Utility functions and services
├── client/ # Frontend React application (WIP)
├── deploy/ # Deployment configurations
├── neo4j/ # Neo4j database migrations and seeds
├── redis/ # Redis setup scripts
└── scripts/ # Utility scripts for development and deployment
```
## Getting Started
### Prerequisites
- Docker and Docker Compose
- Go 1.16 or later (for local development)
- Node.js and npm (for frontend development)
### Running the Application
1. Clone the repository:
```bash
git clone https://github.com/yourusername/echo.git
cd echo
```
2. Start the application using Docker Compose:
```bash
cd deploy
docker-compose up --build
```
3. The API will be available at `http://localhost:8080`
### Development Setup
1. Set up the Go environment:
```bash
cd api
go mod download
```
2. Set up the frontend environment (when ready):
```bash
cd client
npm install
```
3. Run the backend locally:
```bash
cd api
go run main.go
```
4. Run the frontend locally (when ready):
```bash
cd client
npm run dev
```
## API Documentation
[API documentation will be provided here, possibly using Swagger]
## Configuration
Configuration is managed through environment variables and the `config.yaml` file. Key configuration options include:
- `NEO4J_URI`: URI for the Neo4j database
- `REDIS_ADDR`: Address of the Redis server
- `ELASTICSEARCH_URL`: URL of the Elasticsearch instance
- `LOG_LEVEL`: Logging level (e.g., debug, info, warn, error)
For a complete list of configuration options, see `api/config/config.yaml`.
## Contributing
We welcome contributions to Echo! Please see our [Contributing Guide](CONTRIBUTING.md) for more details.
## Testing (WIP)
To run the test suite:
```bash
cd api
go test ./...
```
## License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.