docker-compose.dev.yml

version: "3.7"

# USE --parallel FOR BUILDING

services:
  slashbackend:
    build:
      context: .
      dockerfile: "apps/slashbackend/Dockerfile"
    depends_on:
      - postgres
      - redis
      - voicenode
      - meili
    expose:
      - "8080"
    ports:
      - "9999:8080"
      - "9229:9229"
    networks:
      - databases
      - backend
      - meili
      - minio
    environment:
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      REDIS_PASSWORD: ${REDIS_PASSWORD}
      MEILI_MASTER_KEY: ${MEILI_MASTER_KEY}
      DISCORD_APP_ID: ${DISCORD_APP_ID}
      DISCORD_PUBLIC_KEY: ${DISCORD_PUBLIC_KEY}
      DISCORD_TOKEN: ${DISCORD_TOKEN}
      VOICENODE_ACCESS_KEY: ${VOICENODE_ACCESS_KEY}
    restart: always
    healthcheck:
      test: ["CMD", "curl", "http://localhost:9999/docker-up"]

  uptime-proxy:
    image: ghcr.io/better-airhorn/uptime-proxy:1.0.1
    ports:
      - "9991:9999"
    networks:
      - databases
      - backend
      - meili
      - minio
    environment:
      PORT: 9999
      monit_postgres: postgres:5432
      monit_redis: redis:6379
      monit_minio: http://minio:9000/minio/health/live
      monit_meili: http://meili:7700/health
      monit_voicenode: http://voicenode:8888/health
      monit_slashbackend: http://slashbackend:8080/health
      monit_voteserver: http://voteserver:7777/health

    restart: on-failure

  voicenode:
    build:
      context: .
      dockerfile: "apps/voicenode/Dockerfile"
    expose:
      - "8888"
    networks:
      - backend
      - minio
      - databases
    depends_on:
      - minio
      - postgres
    environment:
      MINIO_ACCESS_KEY: ${MINIO_ACCESS_KEY}
      MINIO_SECRET_KEY: ${MINIO_SECRET_KEY}
      DISCORD_TOKEN: ${DISCORD_TOKEN}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      MINIO_BUCKETNAME: ${MINIO_BUCKETNAME}
      VOICENODE_ACCESS_KEY: ${VOICENODE_ACCESS_KEY}
    restart: on-failure:50
    healthcheck:
      test: ["CMD", "curl", "http://localhost:8888/docker-up"]

  voteserver:
    build:
      context: .
      dockerfile: "apps/voteserver/Dockerfile"
    expose:
      - "7777"
    networks:
      - backend
      - databases
    depends_on:
      - minio
      - postgres
    environment:
      REDIS_PASSWORD: ${REDIS_PASSWORD}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    restart: always
    healthcheck:
      test: ["CMD", "curl", "http://localhost:7777/docker-up"]

  bot:
    build:
      context: .
      dockerfile: "apps/bot/Dockerfile"
    networks:
      - databases
    depends_on:
      - postgres
    environment:
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      DISCORD_APP_ID: ${DISCORD_APP_ID}
      DISCORD_TOKEN: ${DISCORD_TOKEN}
      NORMAL_COMMANDS_DEADLINE: ${NORMAL_COMMANDS_DEADLINE}
    restart: on-failure:50

  redis:
    image: redis:7.0.0-alpine
    volumes:
      - databases:/data
    networks:
      - databases
    expose:
      - "6379"
    # ! REMOVE
    ports:
      - "6379:6379"
    command: redis-server --requirepass ${REDIS_PASSWORD}
    restart: always
    healthcheck:
      test: ["CMD", "redis-cli", "-a", "${REDIS_PASSWORD}", "ping"]

  postgres:
    image: postgres:14-alpine
    volumes:
      - pgsql:/var/lib/postgresql/data
    networks:
      - databases
    expose:
      - "5432"
    # ! REMOVE
    ports:
      - "5431:5432"
    environment:
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    restart: always
    healthcheck:
      test: ["CMD", "psql", "-U", "postgres", "-c", "SELECT 1"]

  minio:
    image: quay.io/minio/minio:RELEASE.2022-06-03T01-40-53Z
    command: server /data --console-address :9001
    volumes:
      - minio:/data
    environment:
      MINIO_ROOT_USER: ${MINIO_ACCESS_KEY}
      MINIO_ROOT_PASSWORD: ${MINIO_SECRET_KEY}
    expose:
      - "9000"
    # ! REMOVE
    ports:
      - "9000:9000"
      - "9001:9001"
    networks:
      - minio
    restart: always
    healthcheck:
      test: ["CMD", "curl", "http://localhost:9000/health"]

  meili:
    image: getmeili/meilisearch:v0.27.1
    user: "root"
    environment:
      MEILI_MASTER_KEY: ${MEILI_MASTER_KEY}
    expose:
      - "7700"
    networks:
      - meili
    volumes:
      - meili:/home/meili/data.ms
    ports:
      - "7700:7700"
    restart: always
    healthcheck:
      test: ["CMD", "curl", "http://localhost:7700/health"]

networks:
  databases:
  backend:
  minio:
  meili:

volumes:
  databases:
  meili:
  minio:
  pgsql: