docker-compose.yaml

services:
    admin:
      container_name: "admin"
      build: ./services/admin
      env_file:
        - .env
      environment:
        DJANGO_SUPERUSER_PASSWORD: ${ADMIN_DJANGO_SUPERUSER_PASSWORD}
      depends_on:
        admin_db:
          condition: service_healthy
      volumes:
        - ./services/admin/static:/app/static
      healthcheck:
        test: ["CMD-SHELL", "[ -e /app/static ]"]
        interval: 5s
        timeout: 10s
        retries: 15 

    admin_db:
      container_name: "admin_db"
      build: ./services/admin_db
      environment:
          POSTGRES_DB: ${ADMIN_DJANGO_DB_NAME}
          POSTGRES_USER: ${ADMIN_DJANGO_DB_USER}
          POSTGRES_PASSWORD: ${ADMIN_DJANGO_DB_PASSWORD}
          POSTGRES_HOST: ${ADMIN_DJANGO_DB_HOST}
          POSTGRES_PORT: ${ADMIN_DJANGO_DB_PORT}
      env_file:
        - .env
      volumes:
        - ./services/admin_db/data:/var/lib/postgresql/data
      healthcheck:
          test: ["CMD-SHELL", "pg_isready -d admin_database -U postgres"] 
          interval: 2s
          timeout: 10s
          retries: 30

    auth:
      container_name: "auth"
      build: ./services/auth
      volumes:
        - ./services/auth:/app:ro
        - ./services/auth/logs:/app/logs
      env_file:
        - .env
      depends_on:
        auth_db:
          condition: service_healthy
        redis:
          condition: service_healthy
      healthcheck:
        test: ["CMD-SHELL", "curl -f http://localhost:${AUTH_SERVICE_PORT}/health || exit 1"]
        interval: 10s
        timeout: 5s
        retries: 3

    elk-auth-filebeat:
      container_name: elk-auth-filebeat
      build:
        context: ./services/auth/filebeat
      env_file:
        - .env
      volumes:
        - ./services/auth/logs:/var/app/log
      depends_on:
        - auth
        - elk-elasticsearch
        - elk-logstash

    auth_db:
      container_name: "auth_db"
      build: ./services/auth_db
      environment:
          POSTGRES_DB: ${AUTH_POSTGRES_DB_NAME}
          POSTGRES_USER: ${AUTH_POSTGRES_USER}
          POSTGRES_PASSWORD: ${AUTH_POSTGRES_PASSWORD}
          POSTGRES_HOST: ${AUTH_POSTGRES_HOST}
          POSTGRES_PORT: ${AUTH_POSTGRES_PORT}

      volumes:
        - ./services/auth_db/data:/var/lib/postgresql/data
        - ./services/auth_db/docker-entrypoint-initdb:/docker-entrypoint-initdb.d/:ro
      healthcheck:
          test: ["CMD-SHELL", "pg_isready -d auth_db -U admin"] 
          interval: 2s
          retries: 100

    content:
      container_name: "content"
      build: ./services/content
      volumes:
        - ./services/content:/app:ro
        - ./services/content/logs:/app/logs
      env_file:
        - .env
      depends_on:
        - elasticsearch
        - redis
      healthcheck:
        test: ["CMD-SHELL", "curl -f http://localhost:${API_SERVICE_PORT}/health || exit 1"]
        interval: 10s
        timeout: 5s
        retries: 3

    elk-content-filebeat:
      container_name: elk-content-filebeat
      build:
        context: ./services/content/filebeat
      env_file:
        - .env
      volumes:
        - ./services/content/logs:/var/app/log
      depends_on:
        - content
        - elk-elasticsearch
        - elk-logstash

    elasticsearch:
      container_name: "elasticsearch"
      image: elasticsearch:8.12.1
      volumes:
        - ./services/es/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml:ro
        - ./services/es/data:/usr/share/elasticsearch/data
      healthcheck:
        test: ["CMD-SHELL", "curl -s http://localhost:${ETL_ELASTIC_PORT}/_cat/health?h=status | grep -q green"]
        retries: 90
        interval: 3s
      deploy:
        resources:
          limits:
            memory: 4GB

    etl_content:
      container_name: "etl_content"
      build: ./services/etl_content
      volumes:
        - ./services/etl_content:/app:ro
        - ./services/etl_content/logs:/app/logs
      env_file:
        - .env
      depends_on: 
        elasticsearch:
          condition: service_healthy

    jaeger:
      image: jaegertracing/all-in-one:latest
      container_name: jaeger
      ports:
        - ${JAEGER_PORTS}
      depends_on:
        nginx:
          condition: service_started

    redis:
      build: ./services/redis
      container_name: "redis"
      volumes: 
        - ./services/redis/data:/data
      restart: always
      healthcheck:
        test: ["CMD", "redis-cli", "ping"]
        timeout: 10s
        retries: 5
        start_period: 10s
      ports:
        - ${REDIS_PORTS}

    nginx:
      container_name: "nginx"
      restart: always
      build: ./services/nginx
      volumes:
        - ./services/nginx/nginx.conf:/etc/nginx/nginx.conf:ro
        - ./services/nginx/configs:/etc/nginx/conf.d:ro
        - ./services/admin/static:/static/:ro
        - ./services/nginx/logs:/var/log/nginx/
      ports:
        - ${NGINX_PORTS}

    elk-nginx-filebeat:
      container_name: elk-nginx-filebeat
      env_file:
        - .env
      build:
        context: ./services/nginx/filebeat
      volumes:
        - ./services/nginx/logs:/var/log/nginx:ro
      depends_on:
        - nginx
        - elk-elasticsearch
        - elk-logstash

    ugc:
      build: './services/ugc'
      container_name: ugc
      environment:
        UGC_JWT_SECRET_KEY: ${AUTH_JWT_SECRET_KEY}
        UGC_JWT_ALGORITHM: ${AUTH_JWT_ALGORITHM}
      volumes:
        - ./services/ugc:/app:ro
        - ./services/ugc/logs:/app/logs
      env_file:
        - .env
      depends_on:
        - mongodb
        - kafka
      healthcheck:
        test: ["CMD-SHELL", "curl -f http://localhost:${UGC_SERVICE_PORT}/health || exit 1"]
        interval: 10s
        timeout: 5s
        retries: 3

    elk-ugc-filebeat:
      container_name: elk-ugc-filebeat
      build:
        context: ./services/ugc/filebeat
      env_file:
        - .env
      volumes:
        - ./services/ugc/logs:/var/app/log
      depends_on:
        - ugc
        - elk-elasticsearch
        - elk-logstash

    kafka:
      build: ./services/kafka
      container_name: kafka
      env_file:
        - .env
      volumes:
        - ./services/kafka/data:/bitnami/kafka
      healthcheck:
        test: kafka-cluster.sh cluster-id --bootstrap-server localhost:9092 || exit 1
        interval: 1s
        timeout: 60s
        retries: 60

    kafka-ui:
      image: provectuslabs/kafka-ui:v0.7.2
      container_name: kafka-ui
      env_file:
        - .env
      ports:
        - ${KAFKA_UI_PORTS}

    etl_ugc:
      build: ./services/etl_ugc
      container_name: etl_ugc
      volumes:
        - ./services/etl_ugc:/app:ro
        - ./services/etl_ugc/logs:/app/logs
      env_file:
        - .env
      depends_on:
        clickhouse:
          condition: service_healthy
        kafka:
          condition: service_healthy
      restart: always

    clickhouse:
      build: ./services/clickhouse
      container_name: clickhouse
      ports:
        - ${CLICKHOUSE_SERVICE_PORTS}
      env_file:
        - .env
      volumes:
        - ./services/clickhouse/data:/var/lib/clickhouse
        - ./services/clickhouse/logs:/var/log/clickhouse-server
      healthcheck:
        test: wget --no-verbose --tries=3 --spider http://localhost:${CLICKHOUSE_SERVICE_PORT}/ping || exit 1

    mongodb:
      build: ./services/mongodb
      container_name: mongodb
      volumes:
        - ./services/mongodb/data:/data/db
      ports:
        - ${UGC_MONGODB_PORTS}
      restart: unless-stopped 

    elk-kibana:
      container_name: "elk-kibana"
      image: kibana:8.12.1
      ports:
        - ${ELK_KIBANA_PORTS}
      depends_on: 
        - elk-elasticsearch
      env_file:
        - .env
      volumes:
        - "./services/elk-kibana/config/kibana.yml:/usr/share/kibana/config/kibana.yml"
      healthcheck:
        test: ["CMD", "curl", "-f", "http://localhost:${ELK_KIBANA_PORT}"]
        retries: 300
        interval: 2s

    elk-elasticsearch:
      container_name: "elk-elasticsearch"
      image: elasticsearch:8.12.1
      ports:
        - ${ELK_ELASTIC_PORTS}
      env_file:
        - .env
      volumes:
        - ./services/elk-es/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml:ro
        - ./services/elk-es/data:/usr/share/elasticsearch/data
      healthcheck:
        test: ["CMD-SHELL", "curl -s http://localhost:${ELK_ELASTIC_PORT}/_cat/health?h=status | grep -q green"]
        retries: 90
        interval: 3s
      deploy:
        resources:
          limits:
            memory: 4GB

    elk-logstash:
      container_name: "elk-logstash"
      image: logstash:8.10.2
      depends_on: 
        - elk-elasticsearch
      env_file:
        - .env
      environment:
        XPACK_MONITORING_ENABLED: "false"
        ES_HOST: "${ELK_ELASTIC_HOST}:9200"
      ports:
        - ${ELK_LOGSTASH_PORTS}
      volumes:
        - ./services/elk-logstash/logstash.conf:/config/logstash.conf:ro
      command: logstash -f /config/logstash.conf

    assistant:
      container_name: assistant
      build: ./services/assistant
      volumes:
        - ./services/assistant:/app:ro
        - ./services/assistant/logs:/app/logs
        - ./services/assistant/data:/app/data
      healthcheck:
        test: ["CMD-SHELL", "curl -f http://localhost:${ASSISTANT_SERVICE_PORT}/health || exit 1"]
        retries: 90
        interval: 3s
      env_file:
        - .env
      depends_on:
        - content

    elk-assistant-filebeat:
      container_name: elk-assistant-filebeat
      build:
        context: ./services/assistant/filebeat
      env_file:
        - .env
      volumes:
        - ./services/assistant/logs:/var/app/log
      depends_on:
        - assistant
        - elk-elasticsearch
        - elk-logstash