Odyssey - Drone Fleet Management Platform

This demo showcases the live dashboard monitoring a drone, receiving a "Return to Base" command, and planning a new multi-point mission which is then persisted to the database. The entire backend is running in a Kubernetes cluster.

Demo: https://vimeo.com/manage/videos/1122329503

• ✅ Real-Time Geospatial Visualization: A live-updating map displaying the precise location of every drone in the fleet.
• ✅ Two-Way Communication: Drones stream high-frequency telemetry via gRPC, and operators can issue commands (Ping, Return to Base) back to specific drones via a REST API.
• ✅ Stateful Mission Planning: An interactive UI allows operators to visually create, name, and save complex multi-point missions to a PostgreSQL database.
• ✅ Resilient & Decoupled Architecture: Backend microservices communicate asynchronously using a RabbitMQ message queue, ensuring zero data loss and high availability even if services fail.
• ✅ Containerized & Orchestrated: The entire platform, including all services and infrastructure, is containerized with Docker and orchestrated with Kubernetes, mirroring a production-grade deployment.
• ✅ Automated CI/CD Pipeline: Every push to the main branch automatically triggers a GitHub Actions pipeline to build, test, and publish all Docker images to a container registry, ready for deployment.

Odyssey is built on a modern, polyglot microservice architecture. The system is designed to be scalable, resilient, and maintainable, with a clear separation of concerns between services.

• Data Flow: Telemetry flows from Simulator → Telemetry Service (via gRPC) → RabbitMQ → Persistence Service → PostgreSQL Database.
• Command Flow: Commands flow from Dashboard → C2 Service (via REST) → Simulator (real-time) or Database (missions).
• Real-time Updates: Live telemetry streams from Telemetry Service → Dashboard via WebSocket.

The simplest way to run the entire Odyssey platform on your local machine is with Docker Compose.

• Git
• Docker Desktop (with Docker Compose V2)
• Node.js and npm

1. Clone the repository:

   git clone https://github.com/your-username/odyssey.git
   cd odyssey

2. Start the entire backend stack: This single command will build the Docker images for all services and start them in the correct order.

   docker-compose up --build

   The backend is now running. You will see logs from all services in your terminal.

3. Run the web dashboard: In a new terminal window, navigate to the web directory, install dependencies, and start the development server.

   cd web/dashboard
   npm install
   npm start

4. Access Mission Control: Open your browser and navigate to http://localhost:3000.

This project is configured for a full Kubernetes deployment, mirroring a production environment.

1. Prerequisites: Ensure Kubernetes is enabled in Docker Desktop.
2. Build Local Images: Run docker build for each service as detailed in the development workflow.
3. Configure Secrets: Copy k8s/postgres-secret.template.yml to k8s/postgres-secret.yml and provide a password.
4. Deploy: Apply all manifests to the cluster:

   kubectl apply -f k8s/

5. Access: The telemetry-service and c2-service are exposed via NodePorts on localhost:30080 and localhost:30081 respectively.

The project includes a full CI/CD pipeline defined in .github/workflows/deploy.yml to automate deployment to a managed Kubernetes cluster on AWS EKS.

• On every push to main, the workflow automatically builds all service images and pushes them to Docker Hub.
• A subsequent job connects to the EKS cluster, updates the image tags using Kustomize, and applies the manifests for a seamless rolling update.
• An Ingress Controller is used to manage external traffic, routing API and WebSocket requests to the appropriate services.