docker-compose-nologs.yml

networks:
  aegis guard: {}

  atlas:
    internal: true

  sentinel:
    internal: true

  alfred_network:
    internal: true

  mnemosine_network:
    internal: true

  petrus_network:
    internal: true

volumes:
  shared_code:
    driver: local
    driver_opts:
      type: none
      device: ./requirements/shared_code
      o: bind

  alfred_data:
    driver: local

  mnemosine_data:
    driver: local

  petrus_data:
    driver: local

  vault_data: {}

  token_alfred_data: {}

  token_alfred_db_data: {}

  token_shared_data: {}

  token_mnemosine_data: {}

  token_mnemosine_db_data: {}

  token_petrus_data: {}

  token_petrus_db_data: {}

  token_root_data: {}

  token_env_data: {}

services:
# # Reverse proxy container
  aegis:
    depends_on:
      alfred:
        condition: service_healthy
      coubertin:
        condition: service_healthy
      cupidon:
        condition: service_healthy
      hermes:
        condition: service_healthy
      ludo:
        condition: service_healthy
      malevitch:
        condition: service_started
      mnemosine:
        condition: service_healthy
      petrus:
        condition: service_healthy
      tutum:
        condition: service_started
    container_name: aegis
    build:
      context: ./requirements/aegis
      dockerfile: Dockerfile
      args:
        PROXY_CONF: $PROXY_CONF
    env_file: .env
    ports:
      # - "80:80"
      # - "443:443"
      - "7999:80"
      - "8000:443"
    volumes:
      - ./requirements/aegis:/usr/share/nginx/html
      - /etc/letsencrypt/archive/batch42.me:/etc/letsencrypt/live/batch42.me:r
    networks:
      - aegis guard
      - atlas
      - sentinel
    restart: on-failure
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "curl http://localhost:8000 | echo -e 'cannot curl'",
        ]
      interval: 10s
      timeout: 10s
      retries: 120

# # Profil container
  alfred:
    depends_on:
      alfred_db:
        condition: service_healthy
      tutum:
        condition: service_healthy
    container_name: alfred
    image: alfred
    build:
      context: ./requirements/alfred
      dockerfile: Dockerfile
    environment:
      ALFRED_USER: alfred
      ALFRED_PASSWORD: alfred_pass
      ALFRED_DB: user_management
      NOLOGS: true
    volumes:
      - ./requirements/alfred/alfred_project:/app
      - token_alfred_data:/app/tokens
      - shared_code:/app/shared
    ports:
      - "8001:8001"
    networks:
      - atlas
      - alfred_network
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "python3",
          "/app/shared/curl.py",
          "http://localhost:8001/healthcheck/"
        ]
      interval: 5s
      timeout: 5s
      retries: 5
      start_period: 10s
    restart: on-failure

# # Profil database container
  alfred_db:
    depends_on:
      tutum:
        condition: service_healthy
    image: alfred_db
    container_name: alfred_db
    build:
      context: ./requirements/alfred_db/
      dockerfile: Dockerfile
    environment:
      POSTGRES_DB: alfred_db
      POSTGRES_USER: alfred_user
      POSTGRES_PASSWORD: alfred_password
      ALFRED_USER: alfred
      ALFRED_PASSWORD: alfred_pass
      ALFRED_DB: user_management
    volumes:
      - token_alfred_db_data:/tokens
      - alfred_data:/var/lib/postgresql/data
    networks:
      - alfred_network
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -d user_management -U alfred"]
      interval: 5s
      timeout: 5s
      retries: 5

# # Tournament container
  coubertin:
    container_name: coubertin
    environment:
      NOLOGS: true
    image: coubertin
    build:
      context: ./requirements/coubertin
      dockerfile: Dockerfile
    volumes:
      - ./requirements/coubertin/coubertin_project:/app
      - token_shared_data:/app/tokens
      - shared_code:/app/shared
    ports:
      - "8002:8002"
    networks:
      - atlas
    depends_on:
      tutum:
        condition: service_healthy
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "python3",
          "/app/shared/curl.py",
          "http://localhost:8002/healthcheck/"
        ]
    restart: on-failure

# # Matchmaking container
  cupidon:
    container_name: cupidon
    environment:
      NOLOGS: true
    image: cupidon
    build:
      context: ./requirements/cupidon
      dockerfile: Dockerfile
    volumes:
      - ./requirements/cupidon/cupidon_project:/app
      - token_shared_data:/app/tokens
      - shared_code:/app/shared
    ports:
      - "8003:8003"
    networks:
      - atlas
    depends_on:
      tutum:
        condition: service_healthy
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "python3",
          "/app/shared/curl.py",
          "http://localhost:8003/healthcheck/"
        ]
    restart: on-failure

# # Notification container
  hermes:
    container_name: hermes
    environment:
      NOLOGS: true
    image: hermes
    build:
      context: ./requirements/hermes
      dockerfile: Dockerfile
    volumes:
      - ./requirements/hermes/hermes_project:/app
      - token_shared_data:/app/tokens
      - shared_code:/app/shared
    ports:
      - "8004:8004"
    networks:
      - atlas
    depends_on:
      tutum:
        condition: service_healthy
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "python3",
          "/app/shared/curl.py",
          "http://localhost:8004/healthcheck/"
        ]
    restart: on-failure

# # Game container
  ludo:
    container_name: ludo
    environment:
      NOLOGS: true
    image: ludo
    build:
      context: ./requirements/ludo
      dockerfile: Dockerfile
    volumes:
      - ./requirements/ludo/ludo_project:/app
      - shared_code:/app/shared
      - token_shared_data:/app/tokens
    ports:
      - "8006:8006"
    networks:
      - atlas
    depends_on:
      tutum:
        condition: service_healthy
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "python3",
          "/app/shared/curl.py",
          "http://localhost:8006/healthcheck/"
        ]
    restart: on-failure

# # Front container
  malevitch:
    container_name: malevitch
    image: malevitch
    build:
      context: ./requirements/malevitch
      dockerfile: Dockerfile
    volumes:
      - ./requirements/malevitch:/usr/share/nginx/html
    ports:
      - "8007:80"
    networks:
      - atlas
    restart: on-failure

# # Stats container
  mnemosine:
    depends_on:
      mnemosine_db:
        condition: service_healthy
      tutum:
        condition: service_healthy
    container_name: mnemosine
    image: mnemosine
    build:
      context: ./requirements/mnemosine
      dockerfile: Dockerfile
    volumes:
      - ./requirements/mnemosine/mnemosine_project:/app
      - token_mnemosine_data:/app/tokens
      - shared_code:/app/shared
    environment:
      NOLOGS: true
      MNEMOSINE_USER: mnemosine
      MNEMOSINE_PASSWORD: 'mnemosine_pass'
      MNEMOSINE_DB: memory_management
    ports:
      - "8008:8008"
    networks:
      - atlas
      - mnemosine_network
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "python3",
          "/app/shared/curl.py",
          "http://localhost:8008/healthcheck/"
        ]
    restart: on-failure

# # Stats database container
  mnemosine_db:
    depends_on:
      tutum:
        condition: service_healthy
    image: mnemosine_db
    container_name: mnemosine_db
    build:
      context: ./requirements/mnemosine_db/
      dockerfile: Dockerfile
    environment:
      POSTGRES_DB: mnemosine_db
      POSTGRES_USER: mnemosine_user
      POSTGRES_PASSWORD: mnemosine_password
      MNEMOSINE_USER: mnemosine
      MNEMOSINE_PASSWORD: 'mnemosine_pass'
      MNEMOSINE_DB: memory_management
    volumes:
      - token_mnemosine_db_data:/tokens
      - mnemosine_data:/var/lib/postgresql/data
    networks:
      - mnemosine_network
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -d memory_management -U mnemosine"]
      interval: 5s
      timeout: 5s
      retries: 5

# # Authentification container
  petrus:
    depends_on:
      petrus_db:
        condition: service_healthy
      tutum:
        condition: service_healthy
    container_name: petrus
    image: petrus
    build:
      context: ./requirements/petrus
      dockerfile: Dockerfile
    environment:
      NOLOGS: true
      PETRUS_USER: petrus
      PETRUS_PASSWORD: 'petrus_pass'
      PETRUS_DB: auth_management
    volumes:
      - ./requirements/petrus/petrus_project:/app
      - shared_code:/app/shared
      - token_petrus_data:/app/tokens
    ports:
      - "8009:8009"
    networks:
      - atlas
      - petrus_network
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "python3",
          "/app/shared/curl.py",
          "http://localhost:8009/healthcheck/"
        ]
    restart: on-failure

# # Authentification database container
  petrus_db:
    depends_on:
      tutum:
        condition: service_healthy
    image: petrus_db
    container_name: petrus_db
    build:
      context: ./requirements/petrus_db/
      dockerfile: Dockerfile
    environment:
      POSTGRES_DB: petrus_db
      POSTGRES_USER: petrus_user
      POSTGRES_PASSWORD: petrus_password
      PETRUS_USER: petrus
      PETRUS_PASSWORD: 'petrus_pass'
      PETRUS_DB: auth_management
    volumes:
      - token_petrus_db_data:/tokens
      - petrus_data:/var/lib/postgresql/data
    networks:
      - petrus_network
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -d auth_management -U petrus"]
      interval: 5s
      timeout: 5s
      retries: 5

# # Vault container
  tutum:
    container_name: tutum
    image: tutum
    build:
      context: ./requirements/tutum
      dockerfile: Dockerfile
      args:
        ELASTIC_PASSWORD: $ELASTIC_PASSWORD
        KIBANA_PASSWORD: $KIBANA_PASSWORD
    env_file: .env
    volumes:
      - vault_data:/opt/vault
      - token_alfred_data:/tokens/alfred
      - token_alfred_db_data:/tokens/alfred-db
      - token_shared_data:/tokens/shared-django
      - token_mnemosine_data:/tokens/mnemosine
      - token_mnemosine_db_data:/tokens/mnemosine-db
      - token_petrus_data:/tokens/petrus
      - token_petrus_db_data:/tokens/petrus-db
      - token_root_data:/tokens/root
      - token_env_data:/tokens/env
    ports:
      - "8200:8200"
    networks:
      - atlas
      - sentinel
      - alfred_network
      - mnemosine_network
      - petrus_network
    restart: on-failure
    healthcheck:
      test: ["CMD", "curl", "-sSf", "http://localhost:8200/v1/sys/health"]
      interval: 1s
      timeout: 5s
      retries: 120

# # Websocket container
  redis:
    container_name: redis
    image: 'bitnami/redis:latest'
    environment:
      - ALLOW_EMPTY_PASSWORD=yes
    networks:
      - atlas
    restart: on-failure