docker-compose.ytt.yaml

#@ load("@ytt:data", "data")
#@ load("@ytt:template", "template")
---
#@ def skill_image_name(skill):
#@ return "ukpsquare/skill-" + skill.name + ":" + data.values.tag
#@ end

#@ def skill_build(skill):
#@ return {"context": "./skills", "args": { "skill": skill.name}}
#@ end

#@ def skill_environment(skill):
WEB_CONCURRENCY: #@ str(data.values.web_concurrency)
VERIFY_SSL: #@ str(data.values.verify_ssl[data.values.environment])
SQUARE_API_URL: #@ data.values.square_api_url[data.values.environment]
KEYCLOAK_BASE_URL: #@ data.values.keycloak_base_url_https[data.values.environment]
REALM:  #@ data.values.realm
CLIENT_ID: #@ skill.author + "-" + skill.name
#@ end

#@ def skill_env_file(skill):
#@ return ["./skills/" + skill.name + "/.env"]
#@ end

#@ def frontend_traefik_redirect():
#@ if data.values.environment == "production":
#@  return [
#@    "traefik.http.routers.frontend.rule=Host(`" + data.values.frontend_url[data.values.environment] + "`) || Host(`square.ukp.informatik.tu-darmstadt.de`)",
#@    "traefik.http.routers.frontend.middlewares=tuda-redirect",
#@    "traefik.http.middlewares.tuda-redirect.redirectregex.regex=^https://square.ukp.informatik.tu-darmstadt.de/(.*)",
#@    "traefik.http.middlewares.tuda-redirect.redirectregex.replacement=https://" + data.values.frontend_url[data.values.environment] + "/$${1}",
#@    "traefik.http.middlewares.tuda-redirect.redirectregex.permanent=true"
#@  ]
#@ else:
#@  return [
#@    "traefik.http.routers.frontend.rule=Host(`" + data.values.frontend_url[data.values.environment] + "`)"
#@  ]
#@ end
#@ end

#@ def traefik_tls(service):
#@ return [
#@  "traefik.http.routers." + service + ".entrypoints=websecure", 
#@  "traefik.http.routers." + service + ".tls=true", 
#@  "traefik.http.routers." + service + ".tls.certresolver=le"
#@ ]
#@ end

#@ def traefik_prefix(service):
#@ return [
#@  "traefik.http.routers." + service + ".rule=PathPrefix(`/api/" + service + "`)", 
#@  "traefik.http.routers." + service + ".middlewares=" + service + "-stripprefix," + service + "-addprefix", 
#@  "traefik.http.middlewares." + service + "-stripprefix.stripprefix.prefixes=/api/" + service, 
#@  "traefik.http.middlewares." + service + "-addprefix.addPrefix.prefix=/api"
#@  ]
#@ end

version: "3.4"

services:
  traefik:
    image: traefik:v2.8.7
    container_name: traefik
    command:
      - --api.insecure=true
      - --api.dashboard=true
      - --log.level=DEBUG
      - --providers.docker=true
      - --providers.docker.exposedbydefault=false
      - --entrypoints.web.address=:80
      - --entrypoints.websecure.address=:443
      - --accesslog=true
      - --accesslog.format=json
      - --accesslog.filepath=/var/log/traefik/access.log.json
      - --certificatesresolvers.le.acme.tlschallenge=true
      - --certificatesresolvers.le.acme.storage=/certificates/acme.json
      - #@ "--certificatesresolvers.le.acme.email=" + data.values.email
      #@ if/end data.values.environment == "local":
      - --certificatesresolvers.le.acme.caserver=https://acme-staging-v02.api.letsencrypt.org/directory
      - --ping
    labels:
      - "traefik.enable=true"
      #! Global redirect to https
      - "traefik.http.routers.http-catchall.rule=hostregexp(`{host:.+}`)"
      - "traefik.http.routers.http-catchall.entrypoints=web"
      - "traefik.http.routers.http-catchall.middlewares=https-redirect"

      #! Middleware redirect from HTTP to HTTPS
      - "traefik.http.middlewares.https-redirect.redirectscheme.scheme=https"
      - "traefik.http.middlewares.https-redirect.redirectscheme.permanent=true"

      - traefik.http.routers.traefik.service=api@internal
      - traefik.http.routers.traefik.middlewares=auth
      - traefik.http.middlewares.auth.basicauth.users=admin:${SQUARE_ADMIN_PASSWORD}
    ports:
      - "80:80" 
      - "443:443"
      - "8080:8080"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - traefik-public-certificates:/certificates
    healthcheck:
      test: traefik healthcheck --ping
      interval: 20s
      timeout: 10s
      retries: 10

  keycloak:
    image: sihebi/keycloak:16.1.1
    environment:
      DB_VENDOR: postgres
      DB_ADDR: db
      DB_PORT: 5432
      DB_USER: square
      DB_SCHEMA: public
      DB_DATABASE: keycloak
      PROXY_ADDRESS_FORWARDING: "true"
      KEYCLOAK_HOSTNAME: #@ data.values.keycloak_base_url[data.values.environment]
      KEYCLOAK_FRONTEND_URL: #@ data.values.keycloak_base_url[data.values.environment] + "/auth"
    env_file:
      - ./keycloak/.env
    depends_on:
      - db
    labels:
      - "traefik.enable=true"
      - #@ "traefik.http.routers.keycloak.rule=Host(`" + data.values.keycloak_base_url[data.values.environment] + "`) && PathPrefix(`/auth`)" 
      - #@ template.replace(traefik_tls("keycloak"))
    volumes:
      - ./keycloak/themes/terms.ftl:/opt/jboss/keycloak/themes/base/login/terms.ftl
      - ./keycloak/themes/register.ftl:/opt/jboss/keycloak/themes/base/login/register.ftl

  db:
    image: postgres:14
    restart: always
    ports:
      - 5432:5432
    environment:
      POSTGRES_DB: square
    env_file:
      - ./postgres/.env
    volumes:
      - db-data:/var/lib/postgresql/data
      - ./postgres/init:/docker-entrypoint-initdb.d/
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 20s
      timeout: 10s
      retries: 10
  
  virtuoso:
    image: tenforce/virtuoso:virtuoso7.2.5
    environment: 
      VIRT_Database_DatabaseFile: /data/virtuoso_db/virtuoso.db
      VIRT_Database_ErrorLogFile: /data/virtuoso_db/virtuoso.log
      VIRT_Database_LockFile: /data/virtuoso_db/virtuoso.lck
      VIRT_TransactionFile_LockFile: /data/virtuoso_db/virtuoso.trx
      VIRT_xa_persistent_file: /data/virtuoso_db/virtuoso.pxa
      VIRT_Database_ErrorLogLevel: 7
      VIRT_Database_FileExtend: 200
      VIRT_Database_MaxCheckpointRemap: 2000
      VIRT_Database_Striping: 0
      VIRT_Database_TempStorage: TempDatabase
      VIRT_TempDatabase_DatabaseFile: /data/virtuoso_db/virtuoso-temp.db
      VIRT_TempDatabase_TransactionFile: /data/virtuoso_db/virtuoso-temp.trx
      VIRT_Parameters_O_DIRECT: 1
      VIRT_Parameters_ServerThreads: 100
      VIRT_Parameters_CheckpointInterval: 0
      VIRT_Parameters_NumberOfBuffers: 340000
      VIRT_Parameters_MaxDirtyBuffers: 250000
      VIRT_HTTPServer_ServerThreads: 100
      VIRT_HTTPServer_MaxKeepAlives: 50
      VIRT_SPARQL_MaxQueryCostEstimationTime: 600
      VIRT_SPARQL_MaxQueryExecutionTime: 180
    volumes:
      - virtuoso-db:/data/
    ports:
      - 8890:8890
    labels:
      - "traefik.enable=true"
      - #@ template.replace(traefik_tls("virtuoso"))
      - "traefik.http.routers.virtuoso.rule=PathPrefix(`/virtuoso`)"
      - "traefik.http.routers.virtuoso.middlewares=virtuoso-stripprefix"
      - "traefik.http.middlewares.virtuoso-stripprefix.stripprefix.prefixes=/virtuoso"
      - "traefik.http.services.virtuoso.loadbalancer.server.port=8890"

  frontend:
    build: 
      context: ./frontend
      args:
        mode: #@ "" + data.values.environment
    image: #@ "ukpsquare/frontend:" + data.values.tag
    restart: always
    expose:
      - 80
      - 443
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.frontend.priority=1"
      - #@ template.replace(traefik_tls("frontend"))
      - #@ template.replace(frontend_traefik_redirect())

  docs:
    image: #@ "ukpsquare/docs:" + data.values.tag
    build: ./docs
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      WEB_CONCURRENCY: #@ str(data.values.web_concurrency)
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.docs.rule=PathPrefix(`/docs/`)"
      - #@ template.replace(traefik_tls("docs"))

  skill-manager:
    image: #@ "ukpsquare/skill-manager:" + data.values.tag
    build: 
      context: ./skill-manager
      target: build
    ports:
      - 8000:8000
    expose:
      - 8000
    env_file:
      - ./mongodb/.env
      - ./redis/.env
      - ./skill-manager/.env
    environment:
      API_PREFIX: skill-manager
      WEB_CONCURRENCY: 8
      KEYCLOAK_BASE_URL: #@ data.values.keycloak_base_url_https[data.values.environment]
      REALM: #@ data.values.realm
      MONGO_HOST: mongodb
      MONGO_PORT: 27017
      VERIFY_ISSUER: #@ str(data.values.verify_issuer[data.values.environment])
      REDIS_HOST: redis
      REDIS_PORT: 6379
      SQUARE_URL: #@ data.values.square_url[data.values.environment]
      SQUARE_API_URL: #@ data.values.square_api_url[data.values.environment]
    depends_on:
      - mongodb
      - redis
    labels:
      - "traefik.enable=true"
      - #@ template.replace(traefik_tls("skill-manager"))
      - #@ template.replace(traefik_prefix("skill-manager"))

  evaluator:
    image: #@ "ukpsquare/evaluator:" + data.values.tag
    build: 
      context: ./evaluator
      target: build
    ports:
      - 8081:8081
    expose:
      - 8081
    env_file:
      - ./redis/.env
      - ./mongodb/.env
      - ./evaluator/.env
      - ./rabbitmq/.env
    environment:
      API_PREFIX: evaluator
      WEB_CONCURRENCY: #@ str(data.values.web_concurrency)
      KEYCLOAK_BASE_URL: #@ data.values.keycloak_base_url_https[data.values.environment]
      REALM: #@ data.values.realm
      MONGO_HOST: mongodb
      MONGO_PORT: 27017
      REDIS_HOST: redis
      REDIS_PORT: 6379
      MODEL_API_URL: #@ data.values.model_url[data.values.environment]
      VERIFY_ISSUER: #@ str(data.values.verify_issuer[data.values.environment])
      DATASET_DIR: /app/datasets/
      SKILL_MANAGER_API_URL: #@ data.values.square_api_url[data.values.environment] + "/skill-manager"
    depends_on:
      - mongodb
    labels:
      - "traefik.enable=true"
      - #@ template.replace(traefik_tls("evaluator"))
      - #@ template.replace(traefik_prefix("evaluator"))
    volumes:
      - evaluation-datasets:/app/datasets/

  mongodb:
    image: mongo:5.0.4
    restart: always
    volumes:
      - mongo-data:/data/db
      - mongo-dumps:/dumps
    expose:
      - 27017
    env_file:
      - ./mongodb/.env

  rabbit:
    hostname: rabbit
    image: rabbitmq:3-management
    ports:
      - 5672:5672
      - 15672:15672
    env_file:
      - ./rabbitmq/.env

  redis:
    image: redis:latest
    ports:
      - 6379:6379
    env_file:
      - .env
      - ./redis/.env
    command: [ "redis-server", "--requirepass ${REDIS_PASSWORD}" ]

  evaluation_worker:
    image: #@ "ukpsquare/evaluator:" + data.values.tag
    build:
      context: ./evaluator
      target: build
    command: celery -A evaluator.tasks worker -Q evaluation --loglevel=info
    volumes:
      - ./:/usr/src/app
      - /var/run/docker.sock:/var/run/docker.sock
      - evaluation-datasets:/app/datasets/
    env_file:
      - ./evaluator/.env
      - ./mongodb/.env
      - ./rabbitmq/.env
      - ./redis/.env
    environment:
      WEB_CONCURRENCY: #@ str(data.values.web_concurrency)
      VERIFY_SSL: #@ str(data.values.verify_ssl[data.values.environment])
      KEYCLOAK_BASE_URL: #@ data.values.keycloak_base_url_https[data.values.environment]
      DOCKER_HOST_URL: #@ data.values.docker_host_url[data.values.os]
      REALM: #@ data.values.realm
      MONGO_HOST: mongodb
      MONGO_PORT: 27017
      REDIS_HOST: redis
      REDIS_PORT: 6379
      DATASET_DIR: /app/datasets/
      QUEUE: evaluation
    depends_on:
      - mongodb
      - redis
      - rabbit

  maintaining_worker:
    image: #@ "ukpsquare/model-manager:" + data.values.tag
    build:
      context: ./model-manager
      target: build
    command: celery -A tasks worker --loglevel=info
    volumes:
      - ./:/usr/src/app
      - /var/run/docker.sock:/var/run/docker.sock
    env_file:
      - ./mongodb/.env
      - ./rabbitmq/.env
      - ./redis/.env
      - ./model-manager/.env
    environment:
      WEB_CONCURRENCY: #@ str(data.values.web_concurrency)
      VERIFY_SSL: #@ str(data.values.verify_ssl[data.values.environment])
      KEYCLOAK_BASE_URL: #@ data.values.keycloak_base_url_https[data.values.environment]
      DOCKER_HOST_URL: #@ data.values.docker_host_url[data.values.os]
      ONNX_VOLUME: model-inference_onnx-models
      REALM: #@ data.values.realm
      MONGO_HOST: mongodb
      MONGO_PORT: 27017
      CONFIG_VOLUME: square-core_model_configs
      MODEL_API_IMAGE: ukpsquare/model-inference
      MODEL_API_IMAGE_TAG: #@ data.values.tag
    depends_on:
      - maintaining
      - rabbit
      - redis

  maintaining:
    image: #@ "ukpsquare/model-manager:" + data.values.tag
    command: uvicorn model_manager.main:app --host 0.0.0.0 --port 9001 --log-config logging.conf
    build: 
      context: ./model-manager
      target: build
    ports:
      - 9001:9001
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    env_file:
      - ./mongodb/.env
      - ./rabbitmq/.env
      - ./redis/.env
      - ./model-manager/.env
    environment:
      WEB_CONCURRENCY: #@ str(data.values.web_concurrency)
      VERIFY_SSL: #@ str(data.values.verify_ssl[data.values.environment])
      KEYCLOAK_BASE_URL: #@ data.values.keycloak_base_url_https[data.values.environment]
      DOCKER_HOST_URL: #@ data.values.docker_host_url[data.values.os]
      ONNX_VOLUME: model-inference_onnx-models
      REALM: #@ data.values.realm
      CONFIG_PATH: /model_configs
      MONGO_HOST: mongodb
      MONGO_PORT: 27017
      MODEL_API_IMAGE: ukpsquare/model-inference
      MODEL_API_IMAGE_TAG: #@ data.values.tag
    labels:
      - "traefik.enable=true"
      - #@ template.replace(traefik_tls("maintaining"))
      - "traefik.http.routers.maintaining.rule=PathPrefix(`/api/models`)"
      - "traefik.http.routers.maintaining.middlewares=maintaining-stripprefix,maintaining-addprefix"
      - "traefik.http.middlewares.maintaining-stripprefix.stripPrefixRegex.regex=/api/[a-zA-Z0-9_-]+"
      - "traefik.http.middlewares.maintaining-addprefix.addPrefix.prefix=/api"

  main_model:
    image: #@ "ukpsquare/model-inference-transformer:" + data.values.tag
    build:
      context: ./model-inference
      target: build
      args:
        - MODEL_TYPE=transformer
    command: uvicorn model_inference.main:app --host 0.0.0.0 --port 8000 --log-config logging.conf
    env_file:
      - ./model-inference/model_configurations/.env.dpr
      - ./rabbitmq/.env
      - ./redis/.env
      - ./mongodb/.env
    environment:
      WEB_CONCURRENCY: #@ str(data.values.web_concurrency)
      VERIFY_SSL: #@ str(data.values.verify_ssl[data.values.environment])
      KEYCLOAK_BASE_URL: #@ data.values.keycloak_base_url_https[data.values.environment]
      DOCKER_HOST_URL: #@ data.values.docker_host_url[data.values.os]
      CONFIG_PATH: /model_configs
      QUEUE: facebook-dpr-question_encoder-single-nq-base
      CONFIG_VOLUME: square-core_model_configs
    volumes:
      - ./.cache/:/etc/huggingface/.cache/
      - model_configs:/model_configs
      - onnx_models:/onnx_models
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.model-dpr.rule=PathPrefix(`/api/main`)"
      - "traefik.http.routers.model-dpr.entrypoints=websecure"
      - "traefik.http.routers.model-dpr.tls=true"
      - "traefik.http.routers.model-dpr.tls.certresolver=le"
      - "traefik.http.routers.model-dpr.middlewares=model-dpr-stripprefix,model-dpr-addprefix"
      - "traefik.http.middlewares.model-dpr-stripprefix.stripprefix.prefixes=/api/main"
      - "traefik.http.middlewares.model-dpr-addprefix.addPrefix.prefix=/api"

  sensitivity: 
    image: #@ "ukpsquare/sensitivity:" + data.values.tag
    build:
      context: ./sensitivity
    volumes:
      - hf_models:/root/.cache/huggingface
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.sensitivity.rule=PathPrefix(`/api/sensitivity`)"
      - "traefik.http.routers.sensitivity.entrypoints=websecure"
      - "traefik.http.routers.sensitivity.tls=true"
      - "traefik.http.routers.sensitivity.tls.certresolver=le"
      - "traefik.http.routers.sensitivity.middlewares=sensitivity-stripprefix,sensitivity-addprefix"
      - "traefik.http.middlewares.sensitivity-stripprefix.stripPrefixRegex.regex=/api/[a-zA-Z0-9_-]+"
      - "traefik.http.middlewares.sensitivity-addprefix.addPrefix.prefix=/api"

  replicate:
    image: #@ "ukpsquare/replicate:" + data.values.tag
    build: 
      context: ./replicate
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.replicate.rule=PathPrefix(`/api/replicate`)"
      - "traefik.http.routers.replicate.entrypoints=websecure"
      - "traefik.http.routers.replicate.tls=true"
      - "traefik.http.routers.replicate.tls.certresolver=le"
      - "traefik.http.routers.replicate.middlewares=replicate-stripprefix,replicate-addprefix"
      - "traefik.http.middlewares.replicate-stripprefix.stripPrefixRegex.regex=/api/[a-zA-Z0-9_-]+"
      - "traefik.http.middlewares.replicate-addprefix.addPrefix.prefix=/api"

  dpr_worker:
    image: #@ "ukpsquare/model-inference-transformer:" + data.values.tag
    build:
      context: ./model-inference
      target: build
      args:
        - MODEL_TYPE=transformer
    container_name: facebook-dpr-question_encoder-single-nq-base
    command: celery -A tasks worker -Q facebook-dpr-question_encoder-single-nq-base --loglevel=info
    volumes:
      - ./:/usr/src/app
      - /var/run/docker.sock:/var/run/docker.sock
      - model_configs:/model_configs
    env_file:
      - ./model-inference/model_configurations/.env.dpr
      - ./rabbitmq/.env
      - ./redis/.env
      - ./mongodb/.env
    environment:
      WEB_CONCURRENCY: #@ str(data.values.web_concurrency)
      VERIFY_SSL: #@ str(data.values.verify_ssl[data.values.environment])
      KEYCLOAK_BASE_URL: #@ data.values.keycloak_base_url_https[data.values.environment]
      DOCKER_HOST_URL: #@ data.values.docker_host_url[data.values.os]
      ONNX_VOLUME: onnx_models
      REALM: #@ data.values.realm
      CONFIG_PATH: /model_configs
      QUEUE: facebook-dpr-question_encoder-single-nq-base
    depends_on:
      - maintaining
      - rabbit
      - redis

  bert_worker:
    image: #@ "ukpsquare/model-inference-transformer:" + data.values.tag
    build:
      context: ./model-inference
      target: build
      args:
        - MODEL_TYPE=transformer
    container_name: bert-base-uncased
    command: celery -A tasks worker -Q bert-base-uncased --loglevel=info
    volumes:
      - ./:/usr/src/app
      - /var/run/docker.sock:/var/run/docker.sock
      - model_configs:/model_configs
    env_file:
      - ./model-inference/model_configurations/.env.bert_adapter
      - ./rabbitmq/.env
      - ./redis/.env
      - ./mongodb/.env
    environment:
      WEB_CONCURRENCY: #@ str(data.values.web_concurrency)
      VERIFY_SSL: #@ str(data.values.verify_ssl[data.values.environment])
      KEYCLOAK_BASE_URL: #@ data.values.keycloak_base_url_https[data.values.environment]
      DOCKER_HOST_URL: #@ data.values.docker_host_url[data.values.os]
      ONNX_VOLUME: onnx_models
      REALM: #@ data.values.realm
      CONFIG_PATH: /model_configs
      QUEUE: bert-base-uncased
    depends_on:
      - maintaining
      - rabbit
      - redis
  metaqa_worker:
    image: #@ "ukpsquare/model-inference-transformer:" + data.values.tag
    build:
      context: ./model-inference
      target: build
      args:
        - MODEL_TYPE=transformer
    container_name: metaqa
    command: celery -A tasks worker -Q metaqa --loglevel=info
    volumes:
      - ./:/usr/src/app
      - /var/run/docker.sock:/var/run/docker.sock
      - model_configs:/model_configs
    env_file:
      - ./model-inference/model_configurations/.env.metaqa
      - ./rabbitmq/.env
      - ./redis/.env
      - ./mongodb/.env
    environment:
      WEB_CONCURRENCY: #@ str(data.values.web_concurrency)
      VERIFY_SSL: #@ str(data.values.verify_ssl[data.values.environment])
      KEYCLOAK_BASE_URL: #@ data.values.keycloak_base_url_https[data.values.environment]
      DOCKER_HOST_URL: #@ data.values.docker_host_url[data.values.os]
      ONNX_VOLUME: onnx_models
      REALM: #@ data.values.realm
      CONFIG_PATH: /model_configs
      QUEUE: metaqa 
    depends_on:
      - maintaining
      - rabbit
      - redis


  roberta_worker:
    image: #@ "ukpsquare/model-inference-transformer:" + data.values.tag
    build:
      context: ./model-inference
      target: build
      args:
        - MODEL_TYPE=transformer
    container_name: roberta-base
    command: celery -A tasks worker -Q roberta-base --loglevel=info
    volumes:
      - ./:/usr/src/app
      - /var/run/docker.sock:/var/run/docker.sock
      - model_configs:/model_configs
    env_file:
      - ./model-inference/model_configurations/.env.roberta_adapter
      - ./rabbitmq/.env
      - ./redis/.env
      - ./mongodb/.env
    environment:
      WEB_CONCURRENCY: #@ str(data.values.web_concurrency)
      VERIFY_SSL: #@ str(data.values.verify_ssl[data.values.environment])
      KEYCLOAK_BASE_URL: #@ data.values.keycloak_base_url_https[data.values.environment]
      DOCKER_HOST_URL: #@ data.values.docker_host_url[data.values.os]
      ONNX_VOLUME: onnx_models
      REALM: #@ data.values.realm
      CONFIG_PATH: /model_configs
      QUEUE: roberta-base
    depends_on:
      - maintaining
      - rabbit
      - redis

  qagnn_worker:
    image: #@ "ukpsquare/model-inference-graph-transformer:" + data.values.tag
    build:
      context: ./model-inference
      target: build
      args:
        - MODEL_TYPE=graph_transformer
    container_name: qagnn
    command: celery -A tasks worker -Q qagnn --loglevel=info --concurrency=1
    volumes:
      - ./:/usr/src/app
      - /var/run/docker.sock:/var/run/docker.sock
      - model_configs:/model_configs
      - model_storage:/model_storage
    env_file:
      - ./model-inference/model_configurations/.env.qagnn
      - ./rabbitmq/.env
      - ./redis/.env
      - ./mongodb/.env
    environment:
      WEB_CONCURRENCY: "1"
      VERIFY_SSL: #@ str(data.values.verify_ssl[data.values.environment])
      KEYCLOAK_BASE_URL: #@ data.values.keycloak_base_url_https[data.values.environment]
      DOCKER_HOST_URL: #@ data.values.docker_host_url[data.values.os]
      ONNX_VOLUME: onnx_models
      REALM: #@ data.values.realm
      CONFIG_PATH: /model_configs
      QUEUE: qagnn
    depends_on:
      - maintaining
      - rabbit
      - redis

  datastore_api:
    privileged: true
    image: #@ "ukpsquare/datastore:" + data.values.tag
    build: 
      context: ./datastore-api
      target: build
    depends_on:
      - datastore_es
      - mongodb
    ports:
      - "7000:7000"
    env_file:
      - ./mongodb/.env
      - ./datastore-api/.env
    environment:
      WEB_CONCURRENCY: #@ str(data.values.web_concurrency)
      FAISS_PORT: 5000
      MODEL_API_URL: #@ data.values.model_url[data.values.environment]
      ES_URL: http://datastore_es:9200
      KEYCLOAK_BASE_URL: #@ data.values.keycloak_base_url_https[data.values.environment]
      REALM: #@ data.values.realm
      VERIFY_ISSUER: #@ str(data.values.verify_issuer[data.values.environment])
      MONGO_HOST: mongodb
      MONGO_PORT: 27017
    labels:
      - "traefik.enable=true"
      - #@ template.replace(traefik_tls("datastores"))
      - "traefik.http.routers.datastores.rule=PathPrefix(`/api/datastores`)"
      - "traefik.http.routers.datastores.middlewares=datastores-stripprefix,datastores-addprefix"
      - "traefik.http.middlewares.datastores-stripprefix.stripPrefixRegex.regex=/api/[a-zA-Z0-9_-]+"
      - "traefik.http.middlewares.datastores-addprefix.addPrefix.prefix=/datastores"

  datastore_es:
    image: docker.elastic.co/elasticsearch/elasticsearch:7.16.1
    environment:
      - discovery.type=single-node
    volumes:
      - datastore-api-es:/usr/share/elasticsearch/data
    ports:
      - 7200:9200

  faiss_nq_dpr:
    container_name: faiss_nq_dpr
    image: kwang2049/faiss-instant:latest
    volumes:
      - datastore-api-faiss-nq-dpr:/opt/faiss-instant/resources

  faiss_msmarco_distilbert:
    container_name: faiss_msmarco_distilbert
    image: kwang2049/faiss-instant:latest
    volumes:
      - datastore-api-faiss-msmarco-distilbert:/opt/faiss-instant/resources
  
  faiss_bioasq_distilbert:
    container_name: faiss_bioasq_distilbert
    image: kwang2049/faiss-instant:latest
    volumes:
      - datastore-api-faiss-bioasq-distilbert:/opt/faiss-instant/resources

  #@yaml/text-templated-strings
  #@ for skill in data.values.skills:
  (@= skill.name @):
    image: #@ skill_image_name(skill)
    build: #@ skill_build(skill)
    env_file: #@ skill_env_file(skill)
    environment: #@ skill_environment(skill)
  #@ end

  dozzle:
    image: amir20/dozzle:v4.0.1
    restart: unless-stopped
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      DOZZLE_NO_ANALYTICS: "true"
      DOZZLE_LEVEL: DEBUG
      DOZZLE_BASE: /admin/logs
    labels:
      - traefik.enable=true
      - #@ template.replace(traefik_tls("dozzle"))
      - traefik.http.routers.dozzle.rule=PathPrefix(`/admin/logs`)
      - traefik.http.routers.dozzle.middlewares=auth
    healthcheck:
      test: ["CMD", "/dozzle", "healthcheck"]
      interval: 20s
      timeout: 10s
      retries: 10

  portainer:
    image: portainer/portainer-ce:latest
    command: -H unix:///var/run/docker.sock
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - portainer-data:/data
    labels:
      #! Frontend
      - traefik.enable=true
      - #@ template.replace(traefik_tls("portainer"))
      - traefik.http.routers.portainer.rule=PathPrefix(`/admin/portainer`)
      - traefik.http.services.portainer.loadbalancer.server.port=9000
      - traefik.http.routers.portainer.service=portainer
      - traefik.http.routers.portainer.middlewares=portainer-stripprefix
      - traefik.http.middlewares.portainer-stripprefix.stripprefix.prefixes=/admin/portainer


volumes:
  traefik-public-certificates:
  db-data:
    driver: local
  migrations-data:
    driver: local
  mongo-data:
    driver: local
  mongo-dumps:
    driver: local
  square-redis-data:
    driver: local
  datastore-api-es:
    driver: local
  datastore-api-faiss-nq-dpr:
    driver: local
  datastore-api-faiss-msmarco-distilbert:
    driver: local
  datastore-api-faiss-bioasq-distilbert:
    driver: local
  model_configs:
    driver: local
  model_storage:
    driver: local
  onnx_models:
    driver: local
  evaluation-datasets:
    driver: local
  virtuoso-db: 
    driver: local
  hf_models:
  portainer-data: 
    driver: local