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

.
├── 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:

   git clone https://github.com/yourusername/echo.git
   cd echo

2. Start the application using Docker Compose:

   cd deploy
   docker-compose up --build

3. The API will be available at http://localhost:8080

Development Setup

1. Set up the Go environment:

   cd api
   go mod download

2. Set up the frontend environment (when ready):

   cd client
   npm install

3. Run the backend locally:

   cd api
   go run main.go

4. Run the frontend locally (when ready):

   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 for more details.

Testing (WIP)

To run the test suite:

cd api
go test ./...

License

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