docker-compose.yml

services:
  next-telegram-bots:
    build:
      context: .
      dockerfile: ./apps/next-telegram-bots/Dockerfile
    container_name: tradestream-next-telegram-bots
    env_file: .env
    ports:
      - "${NEXT_TELEGRAM_BOTS_PORT:-3420}:3420"
    restart: always
    networks:
      - dokploy-network
    labels:
      - traefik.enable=true
      - traefik.http.routers.next-telegram-bots.rule=Host(`${DOMAIN:-localhost}`)
      - traefik.http.routers.next-telegram-bots.entrypoints=websecure
      - traefik.http.routers.next-telegram-bots.tls.certResolver=letsencrypt
      - traefik.http.services.next-telegram-bots.loadbalancer.server.port=${NEXT_TELEGRAM_BOTS_PORT:-3420}
    depends_on:
      - computer
      - redis
      - internal-api
      - internal-app
      - srs
      - streamer
      - stream-proxy
      - agent

  stream-proxy:
    build:
      context: .
      dockerfile: ./apps/stream-proxy/Dockerfile
    container_name: tradestream-stream-proxy
    restart: always
    ports:
      - "1936:1935" # RTMP port
      - "8081:8084" # HTTP port
    networks:
      - dokploy-network
    labels:
      - traefik.enable=true
      - traefik.http.routers.stream-proxy.rule=Host(`stream-proxy.${DOMAIN:-localhost}`)
      - traefik.http.routers.stream-proxy.entrypoints=websecure
      - traefik.http.routers.stream-proxy.tls.certResolver=letsencrypt
      - traefik.http.services.stream-proxy.loadbalancer.server.port=8084

  agent:
    build:
      context: .
      dockerfile: ./apps/agent/Dockerfile
    container_name: tradestream-agent
    env_file: .env
    links:
      - computer
    networks:
      - dokploy-network
    labels:
      - traefik.enable=true

  internal-app:
    build:
      context: .
      dockerfile: ./apps/internal-app/Dockerfile
    container_name: tradestream-internal-app
    env_file: .env
    ports:
      - "${INTERNAL_APP_PORT:-5173}:5173"
    restart: always
    networks:
      - dokploy-network
    links:
      - computer
      - redis
      - internal-api
    depends_on:
      computer:
        condition: service_started
      redis:
        condition: service_started
      internal-api:
        condition: service_started
    mem_limit: 2g
    memswap_limit: 2g
    ulimits:
      nofile:
        soft: 65536
        hard: 65536
    labels:
      - traefik.enable=true
      - traefik.http.routers.internal-app.rule=Host(`internal-tradestream.${DOMAIN:-localhost}`)
      - traefik.http.routers.internal-app.entrypoints=websecure
      - traefik.http.routers.internal-app.tls.certResolver=letsencrypt
      - traefik.http.services.internal-app.loadbalancer.server.port=${INTERNAL_APP_PORT:-5173}

  internal-api:
    build:
      context: .
      dockerfile: ./apps/internal-api/Dockerfile
    container_name: tradestream-internal-api
    env_file: .env
    ports:
      - "${INTERNAL_API_PORT:-3030}:3030"
    restart: always
    networks:
      - dokploy-network
    links:
      - redis
    depends_on:
      redis:
        condition: service_started
    labels:
      - traefik.enable=true
      - traefik.http.routers.internal-api.rule=Host(`api.tradestream.${DOMAIN:-localhost}`)
      - traefik.http.routers.internal-api.entrypoints=websecure
      - traefik.http.routers.internal-api.tls.certResolver=letsencrypt
      - traefik.http.services.internal-api.loadbalancer.server.port=${INTERNAL_API_PORT:-3030}
    healthcheck:
      test:
        [
          "CMD",
          "curl",
          "-f",
          "http://0.0.0.0:${INTERNAL_API_PORT:-3030}/health",
        ]
      interval: 10s
      timeout: 5s
      retries: 3
      start_period: 15s

  computer:
    build:
      context: .
      dockerfile: ./apps/computer/Dockerfile
    container_name: tradestream-computer
    ports:
      - 5900:5900
      - 6080:6080
    shm_size: 4g
    restart: always
    env_file: .env
    networks:
      - dokploy-network
    labels:
      - traefik.enable=true
      - traefik.http.routers.computer-vnc.rule=Host(`vnc.computer.tradestream.${DOMAIN:-localhost}`)
      - traefik.http.routers.computer-vnc.entrypoints=websecure
      - traefik.http.routers.computer-vnc.tls.certResolver=letsencrypt
      - traefik.http.services.computer-vnc.loadbalancer.server.port=5900
      - traefik.http.routers.computer-novnc.rule=Host(`computer.tradestream.${DOMAIN:-localhost}`)
      - traefik.http.routers.computer-novnc.entrypoints=websecure
      - traefik.http.routers.computer-novnc.tls.certResolver=letsencrypt
      - traefik.http.services.computer-novnc.loadbalancer.server.port=6080

  streamer:
    build:
      context: .
      dockerfile: ./apps/streamer/Dockerfile
    shm_size: 2g
    container_name: tradestream-streamer
    restart: always
    env_file: .env
    networks:
      - dokploy-network
    links:
      - internal-app
      - internal-api
      - redis
      - srs
    depends_on:
      computer:
        condition: service_started
      internal-app:
        condition: service_started
      internal-api:
        condition: service_started
      redis:
        condition: service_started
    ulimits:
      nofile:
        soft: 65536
        hard: 65536
    mem_limit: 4g
    memswap_limit: 4g

  srs:
    image: ossrs/srs:5
    container_name: tradestream-srs
    env_file: .env
    ports:
      - "2935:1935" # SRS RTMP port (internal 1935 mapped to host 2935)
      - "2985:1985" # SRS HTTP API port (internal 1985 mapped to host 2985)
      - "9080:8080" # SRS HLS/HTTP-FLV port (internal 8080 mapped to host 9080)
      - "8000:8000/udp" # SRS WebRTC UDP port
    restart: always
    networks:
      - dokploy-network
    command: ./objs/srs -c conf/rtmp2rtc.conf
    labels:
      - traefik.enable=true
      - traefik.http.routers.srs.rule=Host(`stream.${DOMAIN:-localhost}`)
      - traefik.http.routers.srs.entrypoints=websecure
      - traefik.http.routers.srs.tls.certResolver=letsencrypt
      - traefik.http.services.srs.loadbalancer.server.port=9080

  redis:
    image: redis:alpine
    container_name: tradestream-redis
    ports:
      - "${REDIS_PORT:-6379}:6379"
    env_file: .env
    volumes:
      - redis-data:/data
    restart: always
    networks:
      - dokploy-network
    command: >
      sh -c "redis-server --appendonly yes 
      $([[ -n \"$REDIS_PASSWORD\" ]] && echo \"--requirepass $REDIS_PASSWORD\" || echo \"\")"
    labels:
      - traefik.enable=true
      - traefik.http.routers.redis.rule=Host(`redis.tradestream.${DOMAIN:-yourdomain.com}`)
      - traefik.http.routers.redis.entrypoints=websecure
      - traefik.http.routers.redis.tls.certResolver=letsencrypt
      - traefik.http.services.redis.loadbalancer.server.port=${REDIS_PORT:-6379}

volumes:
  redis-data:

networks:
  dokploy-network:
    external: true