irfanuruchi/distributed-orchestrator-coordinator repository overview

⁠Distributed Orchestrator Coordinator

This is the coordinator image for my Capstone Project, Distributed Task Orchestration System.

The coordinator is the main control part of the system. It receives tasks, stores them in SQLite, checks the workers, decides where each task should go, and shows the state of the system in the dashboard.

In Version 10, the coordinator also supports capability-aware scheduling. This means it does not send every task to any random healthy worker. It first checks what the task needs. For example, CPU benchmark tasks are sent only to workers with CPU capability, while memory tasks are sent only to workers with MEMORY capability.

⁠Docker Image

docker pull irfanuruchi/distributed-orchestrator-coordinator:v10

⁠Run Coordinator

First create the Docker network:

docker network create orchestrator-net

Then run the coordinator:

docker run -d --name orchestrator-coordinator --network orchestrator-net -p 8000:8000 -v "$(pwd)/data:/app/data" -e DB_PATH=/app/data/orchestrator.db irfanuruchi/distributed-orchestrator-coordinator:v10

Open the dashboard:

http://localhost:8000/dashboard

The SQLite database is mounted to the local data folder. This is used so the task history does not disappear after restarting the coordinator container.

⁠What This Image Includes

This image runs the FastAPI coordinator, the dashboard, the SQLite task queue, the worker registry, and the scheduler logic. It also handles task retries, worker heartbeats, task history, and benchmark requests.

The coordinator supports round-robin scheduling, load-aware scheduling, and capability-aware scheduling. In Version 10, the capability check happens before the normal scheduler decision, so the coordinator first removes workers that cannot run that task and only then chooses from the valid workers.

⁠Useful API Commands

Submit a task:

curl -X POST http://localhost:8000/submit \
  -H "Content-Type: application/json" \
  -d '{"task_type":"cpu_benchmark","payload":"cpu_benchmark","priority":"MEDIUM"}'

Check workers:

curl http://localhost:8000/workers

Check task history:

curl http://localhost:8000/tasks

Run benchmark:

curl -X POST http://localhost:8000/benchmark \
  -H "Content-Type: application/json" \
  -d '{"task_type":"cpu_benchmark","count":5,"priority":"MEDIUM"}'

⁠Running Workers

The coordinator should be started first. Worker containers are started separately and register to the coordinator.

For a local Docker network setup, workers can use:

COORDINATOR_URL=http://orchestrator-coordinator:8000

Workers can also run from another device on the same LAN. In that case, use the LAN IP address of the machine running the coordinator:

COORDINATOR_URL=http://192.168.1.50:8000

The same idea can also work over Tailscale or another private VPN, where the worker uses the coordinator machine's VPN IP:

COORDINATOR_URL=http://100.x.x.x:8000

⁠Version

Current version: V10 Status: Working Dockerized release