docker-compose.yml

services:

  bot:
    container_name: "fanfan-bot-${ENV_NAME}"
    build: .
    env_file:
      - .env
    restart: unless-stopped
    volumes:
      - bot-data:/media/bot-data
    ports:
      - "127.0.0.1:${BOT__WEBHOOK__PORT}:${BOT__WEBHOOK__PORT}"
    depends_on:
      - migration
      - redis
      - nats
    command: ["python", "-m", "fanfan.main.bot"]

  web:
    profiles: [ "web" ]
    container_name: "fanfan-web-${ENV_NAME}"
    build: .
    env_file:
      - .env
    restart: unless-stopped
    stop_signal: SIGINT
    volumes:
      - bot-data:/media/bot-data
    ports:
      - "127.0.0.1:${WEB__PORT}:${WEB__PORT}"
    depends_on:
      - migration
    command: [
      "python",
      "-m",
      "fanfan.main.web",
    ]

  migration:
    container_name: "fanfan-migration-${ENV_NAME}"
    build: .
    restart: on-failure
    env_file:
      - .env
    volumes:
      - bot-data:/media/bot-data
      - ./alembic.ini:/app/alembic.ini
    depends_on:
      db:
        condition: service_healthy
    command: ["sh", "-c", "alembic upgrade head && python -m fanfan.main.migration"]

  db:
    container_name: "fanfan-db-${ENV_NAME}"
    image: postgres:17-alpine
    restart: always
    env_file:
      - .env
    environment:
      - POSTGRES_USER=${DB__USER}
      - POSTGRES_PASSWORD=${DB__PASSWORD}
      - POSTGRES_DB=${DB__NAME}
    volumes:
      - db-data:/var/lib/postgresql/data
    ports:
      - "127.0.0.1:${DB__EXPOSED_PORT}:5432"
    healthcheck:
      test: [ "CMD-SHELL", "pg_isready -d $${POSTGRES_DB} -U $${POSTGRES_USER}" ]
      interval: 2s
      timeout: 60s
      retries: 10
      start_period: 5s

  pgbackup:
    container_name: "fanfan-db-backup-${ENV_NAME}"
    image: prodrigestivill/postgres-backup-local
    restart: always
    volumes:
      - pgbackup-data:/backups
    depends_on:
      - db
    environment:
      - POSTGRES_HOST=db
      - POSTGRES_DB=${DB__NAME}
      - POSTGRES_USER=${DB__USER}
      - POSTGRES_PASSWORD=${DB__PASSWORD}
      - POSTGRES_EXTRA_OPTS=-Z1 --schema=public --blobs
      - SCHEDULE=@every 6h00m00s
      - BACKUP_ON_START=TRUE
      - BACKUP_KEEP_DAYS=7
      - BACKUP_KEEP_WEEKS=4
      - BACKUP_KEEP_MONTHS=6

  redis:
    image: redis:7-alpine
    container_name: "fanfan-redis-${ENV_NAME}"
    command: "redis-server /usr/local/etc/redis/redis.conf --requirepass ${REDIS__PASSWORD}"
    env_file:
      - .env
    restart: always
    volumes:
      - redis-data:/data
      - ./config/redis/redis.conf:/usr/local/etc/redis/redis.conf
    ports:
      - "127.0.0.1:${REDIS__EXPOSED_PORT}:6379"
    healthcheck:
      test: [ "CMD", "redis-cli","ping" ]
      interval: 5s
      timeout: 20s
      retries: 5

  nats:
    container_name: "fanfan-nats-${ENV_NAME}"
    image: docker.io/nats:alpine
    restart: always
    env_file:
      - .env
    ports:
      - "127.0.0.1:${NATS__EXPOSED_PORT}:4222"
    volumes:
      - nats-data:/data
    command: "--js --sd=/data --user ${NATS__USER} --pass ${NATS__PASSWORD}"

  faststream:
    container_name: "fanfan-faststream-${ENV_NAME}"
    build: .
    restart: unless-stopped
    env_file:
      - .env
    volumes:
      - bot-data:/media/bot-data
    depends_on:
      - nats
      - migration
      - redis
    command: ["python", "-m", "fanfan.main.stream"]

  taskiq:
    container_name: "fanfan-taskiq-${ENV_NAME}"
    build: .
    restart: unless-stopped
    env_file:
      - .env
    volumes:
      - bot-data:/media/bot-data
    depends_on:
      - migration
      - redis
      - nats
    command:
      [
        "taskiq",
        "worker",
        "fanfan.main.scheduler:broker",
        "fanfan.presentation.scheduler.tasks",
      ]

  scheduler:
    profiles: ["scheduler"]
    container_name: "fanfan-scheduler-${ENV_NAME}"
    build: .
    depends_on:
      - redis
    restart: unless-stopped
    env_file:
      - .env
    volumes:
      - bot-data:/media/bot-data
    command:
      [
        "taskiq",
        "scheduler",
        "fanfan.main.scheduler:scheduler",
        "fanfan.presentation.scheduler.tasks",
      ]


  grafana:
    profiles: [ "grafana" ]
    image: grafana/grafana:latest
    container_name: "fanfan-grafana-${ENV_NAME}"
    restart: unless-stopped
    ports:
      - "127.0.0.1:3000:3000"
    volumes:
      - grafana-data:/var/lib/grafana:rw
      - ./config/grafana/provisioning:/etc/grafana/provisioning:rw
      - ./config/grafana/dashboards:/etc/grafana/dashboards
    environment:
      - GF_SECURITY_ADMIN_USER=${GRAFANA_USER:-admin}
      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_PASSWORD:-admin}
      - GF_USERS_ALLOW_SIGN_UP=false
      - GF_DATABASE_WAL=true
      - VIRTUAL_HOST=grafana
      - NETWORK_ACCESS=internal
      - VIRTUAL_PORT=3000

  tempo:
    profiles: [ "grafana" ]
    image: grafana/tempo:latest
    container_name: "fanfan-tempo-${ENV_NAME}"
    command: [ "-config.file=/etc/tempo.yaml" ]
    volumes:
      - tempo-data:/var/tempo
      - ./config/tempo/tempo.yaml:/etc/tempo.yaml
    restart: unless-stopped
    ports:
      - "14250:14250"
      - "4317:4317"
      - "3200:3200"

  prometheus:
    profiles: [ "grafana" ]
    image: prom/prometheus:latest
    container_name: "fanfan-prometheus-${ENV_NAME}"
    command:
      - --config.file=/etc/prometheus.yaml
      - --web.enable-remote-write-receiver
      - --enable-feature=exemplar-storage
    volumes:
      - ./config/prometheus/prometheus.yaml:/etc/prometheus.yaml
    ports:
      - "9090:9090"

volumes:
  bot-data: {}
  db-data: {}
  pgbackup-data: {}
  redis-data: {}
  nats-data: {}
  grafana-data: {}
  tempo-data: {}
  loki-data: {}