docker-compose.yaml

services:
  traefik:
    image: traefik:v3.6
    command:
      - "--api.dashboard=true"
      - "--providers.docker=true"
      - "--providers.docker.exposedbydefault=false"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.backend.address=:8000"
      - "--entrypoints.internal.address=:8081"
    ports:
      - "80:80"
      - "8000:8000"
      - "8081:8081"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./traefik-dashboard-users:/dashboard-users:ro
    networks:
      - public-network
      - internal-network
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.dashboard.rule=Host(`traefik.localhost`)"
      - "traefik.http.routers.dashboard.entrypoints=internal"
      - "traefik.http.routers.dashboard.service=api@internal"
      - "traefik.http.routers.dashboard.middlewares=dashboard-auth"
      - "traefik.http.middlewares.dashboard-auth.basicauth.usersfile=/dashboard-users"

  neo4j:
    image: neo4j:latest
    expose:
      - "7474"
      - "7687"
    environment:
      - NEO4J_AUTH=neo4j/${NEO4J_PASSWORD:?NEO4J_PASSWORD required - copy .env.example to .env}
      - NEO4J_apoc_export_file_enabled=true
      - NEO4J_dbms_connector_bolt_listen__address=0.0.0.0:7687
      - NEO4J_dbms_connector_http_listen__address=0.0.0.0:7474
    volumes:
      - neo4j_data:/data
    networks:
      - internal-network
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.neo4j.rule=Host(`neo4j.internal.localhost`)"
      - "traefik.http.routers.neo4j.entrypoints=internal"
      - "traefik.http.services.neo4j.loadbalancer.server.port=7474"
    healthcheck:
      test: [ "CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:7474" ]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 30s

  qdrant:
    image: qdrant/qdrant
    expose:
      - "6333"
    volumes:
      - qdrant_data:/qdrant/storage
    networks:
      - internal-network
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.qdrant.rule=Host(`qdrant.internal.localhost`)"
      - "traefik.http.routers.qdrant.entrypoints=internal"
      - "traefik.http.services.qdrant.loadbalancer.server.port=6333"

  redis:
    image: redis:alpine
    expose:
      - "6379"
    volumes:
      - redis_data:/data
    networks:
      - internal-network

  redis-exporter:
    image: oliver006/redis_exporter:latest
    expose:
      - "9121"
    environment:
      - REDIS_ADDR=redis:6379
    networks:
      - internal-network
    depends_on:
      - redis

  neo4j-exporter:
    image: ghcr.io/petrov-e/neo4j_exporter:v1.0.0-5-g1e176d2
    expose:
      - "5000"
    environment:
      - NEO4J_SERVICE=neo4j:${NEO4J_PASSWORD:?NEO4J_PASSWORD required}@neo4j
    networks:
      - internal-network
    depends_on:
      neo4j:
        condition: service_healthy

  prometheus:
    image: prom/prometheus:latest
    expose:
      - "9090"
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--web.console.libraries=/etc/prometheus/console_libraries'
      - '--web.console.templates=/etc/prometheus/consoles'
      - '--storage.tsdb.retention.time=200h'
      - '--web.enable-lifecycle'
    volumes:
      - ./monitoring/prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    networks:
      - internal-network
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.prometheus.rule=Host(`prometheus.internal.localhost`)"
      - "traefik.http.routers.prometheus.entrypoints=internal"
      - "traefik.http.services.prometheus.loadbalancer.server.port=9090"

  grafana:
    image: grafana/grafana:latest
    expose:
      - "3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_ADMIN_PASSWORD:?GRAFANA_ADMIN_PASSWORD required}
      - GF_USERS_ALLOW_SIGN_UP=false
    volumes:
      - grafana_data:/var/lib/grafana
      - ./monitoring/grafana/datasources:/etc/grafana/provisioning/datasources
      - ./monitoring/grafana/dashboards:/etc/grafana/provisioning/dashboards
    networks:
      - internal-network
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.grafana.rule=Host(`grafana.localhost`)"
      - "traefik.http.routers.grafana.entrypoints=internal"
      - "traefik.http.services.grafana.loadbalancer.server.port=3000"

  backend:
    build: ./backend
    command: sh -c "./.venv/bin/python manage.py init_databases && ./.venv/bin/python manage.py migrate --noinput && ./.venv/bin/python manage.py collectstatic --noinput || true && ./.venv/bin/uvicorn backend.asgi:application --host 0.0.0.0 --port 8000"
    expose:
      - "8000"
    volumes:
      - ./uploads:/app/uploads
      - cv_temp:/tmp/resume_uploads
    env_file:
      - ./backend/.env
    networks:
      - public-network
      - internal-network
    depends_on:
      neo4j:
        condition: service_healthy
      qdrant:
        condition: service_started
      redis:
        condition: service_started
    labels:
      - "traefik.enable=true"
      - "traefik.docker.network=public-network"
      - "traefik.http.routers.backend.rule=Host(`localhost`)"
      - "traefik.http.routers.backend.entrypoints=backend"
      - "traefik.http.services.backend.loadbalancer.server.port=8000"
      - "traefik.http.routers.backend-80.rule=Host(`api.localhost`)"
      - "traefik.http.routers.backend-80.entrypoints=web"

  frontend:
    build:
      context: ./frontend
      target: ${FRONTEND_TARGET:-dev}
    command: sh -c "until wget -qO- http://backend:8000/api/schema/ >/dev/null 2>&1; do sleep 2; done && OPENAPI_URL=http://backend:8000/api/schema/ npm run generate:api && npm run dev"
    ports:
      - "5173:5173"
    volumes:
      - ./frontend:/app
    networks:
      - public-network
    depends_on:
      - backend
    labels:
      - "traefik.enable=true"
      - "traefik.docker.network=public-network"
      - "traefik.http.routers.frontend.rule=Host(`app.localhost`)"
      - "traefik.http.routers.frontend.entrypoints=web"
      - "traefik.http.services.frontend.loadbalancer.server.port=5173"

  backend-worker-processing:
    build: ./backend
    command: sh -c "sleep 5 && ./.venv/bin/python manage.py intake_worker processing"
    volumes:
      - ./uploads:/app/uploads
      - cv_temp:/tmp/resume_uploads
    env_file:
      - ./backend/.env
    networks:
      - internal-network
    depends_on:
      backend:
        condition: service_started
      redis:
        condition: service_started

networks:
  public-network:
    driver: bridge
  internal-network:
    driver: bridge

volumes:
  neo4j_data:
  qdrant_data:
  redis_data:
  prometheus_data:
  grafana_data:
  cv_temp: