docker-compose.yml

version: "3.2"

networks:
  internal_network:

volumes:
  minio:
  dgraph:
  caddy:
  esdata1:
  esdata2:

services:
  # flower - celery dashboard
  flower:
    container_name: flower
    build:
      context: .
      dockerfile: docker/flower/Dockerfile
    networks:
      - internal_network
    volumes:
      - ./scripts:/app:cached
    ports:
      - 5555:5555
    command: [flower, --app=worker.app, --port=5555]
    environment:
      CELERY_BROKER_URL: amqp://guest:guest@rabbit:5672
      CELERY_BACKEND_URL: redis://redis:6379
      TIKA_HOST: http://tika:4219
      ES_HOSTS: http://elasticsearch:9200
      ES_INDEX_DOCS: docs
      HOSTNAME: ${HOSTNAME}
      HTTP_PORT: ${HTTP_PORT}
      HTTPS_PORT: ${HTTPS_PORT}
      DGRAPH_TOKEN: ${DGRAPH_TOKEN}
      JWT_SECRET: ${JWT_SECRET}
      SYSTEM_PWD: ${SYSTEM_PWD}
      ADMIN_PWD: ${ADMIN_PWD}
      # api key protection
      API_KEY_SECRET: ${API_KEY_SECRET}
      API_KEY: ${API_KEY}
      APP_ID: ${APP_ID}
      APP_SECRET: ${APP_SECRET}
      API_GATEWAY_URL: "http://app:4201"

  # celery worker
  worker:
    container_name: worker
    build:
      context: .
      dockerfile: docker/celery/Dockerfile
    networks:
      - internal_network
    volumes:
      - ./scripts:/app:cached
    command:
      [celery, worker, --app=worker.app, --concurrency=3, --loglevel=INFO]
    environment:
      CELERY_BROKER_URL: amqp://guest:guest@rabbit:5672
      CELERY_BACKEND_URL: redis://redis:6379
      TIKA_HOST: http://tika:4219
      ES_HOSTS: http://elasticsearch:9200
      ES_INDEX_DOCS: docs
      HOSTNAME: ${HOSTNAME}
      HTTP_PORT: ${HTTP_PORT}
      HTTPS_PORT: ${HTTPS_PORT}
      DGRAPH_TOKEN: ${DGRAPH_TOKEN}
      JWT_SECRET: ${JWT_SECRET}
      SYSTEM_PWD: ${SYSTEM_PWD}
      ADMIN_PWD: ${ADMIN_PWD}
      # api key protection
      API_KEY_SECRET: ${API_KEY_SECRET}
      API_KEY: ${API_KEY}
      APP_ID: ${APP_ID}
      APP_SECRET: ${APP_SECRET}
      API_GATEWAY_URL: "http://app:4201"

  # listens NATS events and react on them
  reactor:
    container_name: reactor
    build:
      context: .
      dockerfile: docker/reactor/Dockerfile
    networks:
      - internal_network
    volumes:
      - ./scripts:/app:cached
    environment:
      CELERY_BROKER_URL: amqp://guest:guest@rabbit:5672
      CELERY_BACKEND_URL: redis://redis:6379
      TIKA_HOST: http://tika:4219
      NATS_URI: ${NATS_URI}
      HOSTNAME: ${HOSTNAME}
      HTTP_PORT: ${HTTP_PORT}
      HTTPS_PORT: ${HTTPS_PORT}
      DGRAPH_TOKEN: ${DGRAPH_TOKEN}
      JWT_SECRET: ${JWT_SECRET}
      SYSTEM_PWD: ${SYSTEM_PWD}
      ADMIN_PWD: ${ADMIN_PWD}
      # api key protection
      API_KEY_SECRET: ${API_KEY_SECRET}
      API_KEY: ${API_KEY}
      APP_ID: ${APP_ID}
      APP_SECRET: ${APP_SECRET}
      API_GATEWAY_URL: "http://app:4201"

  # message broker for celery
  rabbit:
    container_name: rabbit
    image: rabbitmq
    networks:
      - internal_network
    ports:
      - 5672:5672
    restart: always
    logging:
      driver: "json-file"
      options:
        max-size: ${LOG_MAX_SIZE}
        max-file: ${LOG_MAX_FILE}

  # cache service
  redis:
    container_name: redis
    build:
      context: ./docker/redis
    networks:
      - internal_network
    sysctls:
      - net.core.somaxconn=1024
    ports:
      - 6379:6379
    restart: always
    healthcheck:
      test: "curl --fail http://localhost:6379 || exit 1"
      interval: 60s
      timeout: 60s
      retries: 10
    logging:
      driver: "json-file"
      options:
        max-size: ${LOG_MAX_SIZE}
        max-file: ${LOG_MAX_FILE}

  # file parsers by apache tika
  tika:
    container_name: tika
    build:
      context: ./fparse
    environment:
      FS_HOST: http://app:4201
      SYSTEM_PWD: ${SYSTEM_PWD}
      API_KEY: ${API_KEY}
    volumes:
      - ./fparse:/home/gradle/src
    networks:
      - internal_network
    ports:
      - 4219:4219
    restart: always
    logging:
      driver: "json-file"
      options:
        max-size: ${LOG_MAX_SIZE}
        max-file: ${LOG_MAX_FILE}

  # message bus
  nats:
    image: nats:2-alpine
    container_name: nats
    hostname: nats
    command: nats-server --config /etc/nats-server.conf
    volumes:
      - ./config/nats/nats-server.conf:/etc/nats-server.conf
    networks:
      - internal_network
    ports:
      - 4222:4222
      - 6222:6222
      - 8222:8222
    restart: always
    healthcheck:
      test: "curl --fail http://localhost:4222 || exit 1"
      interval: 60s
      timeout: 60s
      retries: 10
    logging:
      driver: "json-file"
      options:
        max-size: ${LOG_MAX_SIZE}
        max-file: ${LOG_MAX_FILE}

  # Amazon S3 compatible file store
  minio:
    image: minio/minio:latest
    container_name: minio
    networks:
      - internal_network
    volumes:
      - minio:/data
      - ./config/minio:/etc/minio:cached
    ports:
      - 9000:9000
    environment:
      MINIO_ACCESS_KEY: ${AWS_ACCESS_KEY_ID}
      MINIO_SECRET_KEY: ${AWS_SECRET_ACCESS_KEY}
    command: server --config-dir /etc/minio /data
    restart: always
    logging:
      driver: "json-file"
      options:
        max-size: ${LOG_MAX_SIZE}
        max-file: ${LOG_MAX_FILE}

  # image ops service (we need resizing at least)
  imageproxy:
    image: tianon/true
    # image: willnorris/imageproxy
    container_name: imageproxy
    networks:
      - internal_network
    # command: "-addr 0.0.0.0:1081"
    # ports:
    #   - 1081:1081
    # restart: always
    logging:
      driver: "json-file"
      options:
        max-size: ${LOG_MAX_SIZE}
        max-file: ${LOG_MAX_FILE}

  # dgraph cluster manager
  zero:
    image: dgraph/dgraph:v20.03.0-beta.20200320
    container_name: zero
    networks:
      - internal_network
    volumes:
      - dgraph:/dgraph
    ports:
      - 5080:5080
      - 6080:6080
    command: dgraph zero --my=zero:5080 --telemetry=false -v=0
    restart: always
    healthcheck:
      test: "curl --fail --max-time 10 http://localhost:6080/health"
      interval: 60s
      timeout: 60s
      retries: 10
    logging:
      driver: "json-file"
      options:
        max-size: ${LOG_MAX_SIZE}
        max-file: ${LOG_MAX_FILE}

  # dgraph node (GraphQL native database)
  dgraph:
    image: dgraph/dgraph:v20.03.0-beta.20200320
    container_name: dgraph
    networks:
      - internal_network
    volumes:
      - dgraph:/dgraph
    ports:
      - 8080:8080
      - 9080:9080
    command: dgraph alpha --my=dgraph:7080 --zero=zero:5080 --lru_mb=2048 --whitelist=${DGRAPH_WHITELIST} --telemetry=false -v=0
    restart: always
    healthcheck:
      test: "curl --fail --max-time 10 http://localhost:8080/health"
      interval: 60s
      timeout: 60s
      retries: 10
    logging:
      driver: "json-file"
      options:
        max-size: ${LOG_MAX_SIZE}
        max-file: ${LOG_MAX_FILE}

  # dgraph UI
  ratel:
    image: dgraph/dgraph:v20.03.0-beta.20200320
    container_name: ratel
    networks:
      - internal_network
    ports:
      - 8000:8000
    command: dgraph-ratel
    restart: on-failure
    logging:
      driver: "json-file"
      options:
        max-size: ${LOG_MAX_SIZE}
        max-file: ${LOG_MAX_FILE}

  # elasticsearch node1
  # see also https://github.com/deviantony/docker-elk
  # todo elasticsearch production config
  elasticsearch:
    image: tianon/true
    # build:
    #   context: ./
    #   dockerfile: ./docker/elasticsearch/Dockerfile
    container_name: elasticsearch
    networks:
      - internal_network
    ulimits:
      memlock:
        soft: -1
        hard: -1
    volumes:
      - esdata1:/usr/share/elasticsearch/data
    # ports:
    #   - 9200:9200
    # restart: always
    # healthcheck:
    #   test: "curl --fail http://localhost:9200 || exit 1"
    #   interval: 60s
    #   timeout: 60s
    #   retries: 10
    logging:
      driver: "json-file"
      options:
        max-size: ${LOG_MAX_SIZE}
        max-file: ${LOG_MAX_FILE}
  # elasticsearch node2
  elasticsearch2:
    image: tianon/true
    # build:
    #   context: ./
    #   dockerfile: ./docker/elasticsearch/Dockerfile
    container_name: elasticsearch2
    networks:
      - internal_network
    ulimits:
      memlock:
        soft: -1
        hard: -1
    volumes:
      - esdata2:/usr/share/elasticsearch/data
    # restart: always
    # healthcheck:
    #   test: "curl --fail http://localhost:9300 || exit 1"
    #   interval: 60s
    #   timeout: 60s
    #   retries: 10
    logging:
      driver: "json-file"
      options:
        max-size: ${LOG_MAX_SIZE}
        max-file: ${LOG_MAX_FILE}

  # lightweight UI for elasticsearch
  eshead:
    container_name: eshead
    image: tianon/true
    # image: mobz/elasticsearch-head:5-alpine
    # restart: always
    networks:
      - internal_network
    logging:
      driver: "json-file"
      options:
        max-size: ${LOG_MAX_SIZE}
        max-file: ${LOG_MAX_FILE}

  # kibana - elasticsearch dashboard
  kibana:
    image: tianon/true
    # image: docker.elastic.co/kibana/kibana:7.6.1
    container_name: kibana
    environment:
      XPACK_MONITORING_ENABLED: "false"
      ELASTICSEARCH_HOSTS: http://elasticsearch:9200
    networks:
      - internal_network
    volumes:
      - ./config/kibana/:/usr/share/kibana/config:cached
    # ports:
    #   - 5601:5601
    # restart: always
    logging:
      driver: "json-file"
      options:
        max-size: ${LOG_MAX_SIZE}
        max-file: ${LOG_MAX_FILE}

  # pyadmin API service
  pyadmin:
    depends_on:
      - app
    build:
      context: ./
      dockerfile: ./docker/pyadmin/Dockerfile
    container_name: pyadmin
    environment:
      HOSTNAME: ${HOSTNAME}
      HTTP_PORT: ${HTTP_PORT}
      HTTPS_PORT: ${HTTPS_PORT}
      DGRAPH_TOKEN: ${DGRAPH_TOKEN}
      JWT_SECRET: ${JWT_SECRET}
      SYSTEM_PWD: ${SYSTEM_PWD}
      ADMIN_PWD: ${ADMIN_PWD}
      # api key protection
      API_KEY_SECRET: ${API_KEY_SECRET}
      API_KEY: ${API_KEY}
      APP_ID: ${APP_ID}
      APP_SECRET: ${APP_SECRET}
      API_GATEWAY_URL: "http://app:4201"
      FLASK_ENV: development
      FLASK_PORT: 4211
    volumes:
      - ./scripts:/pyadmin:cached
      - ./schema.txt:/schema.txt:cached
      - ./docker/pyadmin/main.sh:/main.sh:cached
    networks:
      - internal_network
    ports:
      - 4211:4211
    restart: always
    logging:
      driver: "json-file"
      options:
        max-size: ${LOG_MAX_SIZE}
        max-file: ${LOG_MAX_FILE}

  # application API service
  app:
    depends_on:
      - dgraph
      - minio
      - nats
    build:
      context: ./
      dockerfile: ./docker/app/Dockerfile
    container_name: app
    environment:
      PORT: 4201
      HOSTNAME: ${HOSTNAME}
      HTTP_PORT: ${HTTP_PORT}
      HTTPS_PORT: ${HTTPS_PORT}
      DGRAPH_TOKEN: ${DGRAPH_TOKEN}
      DGRAPH_RPC_URL: dgraph:9080
      DGRAPH_HTTP_URL: http://dgraph:8080
      ES_HOSTS: http://elasticsearch:9200
      NATS_URI: nats://nats:4222
      JWT_SECRET: ${JWT_SECRET}
      SYSTEM_EMAIL: ${SYSTEM_EMAIL}
      SYSTEM_PWD: ${SYSTEM_PWD}
      ADMIN_EMAIL: ${ADMIN_EMAIL}
      ADMIN_PWD: ${ADMIN_PWD}
      # api key protection
      API_KEY_SECRET: ${API_KEY_SECRET}
      APP_ID: ${APP_ID}
      APP_SECRET: ${APP_SECRET}
      # aws services
      AWS_S3_ENDPOINT: ${AWS_S3_ENDPOINT}
      AWS_S3_BUCKET: ${AWS_S3_BUCKET}
      AWS_ACCESS_KEY_ID: ${AWS_ACCESS_KEY_ID}
      AWS_SECRET_ACCESS_KEY: ${AWS_SECRET_ACCESS_KEY}
      AWS_REGION: ${AWS_REGION}
      # oauth config
      FACEBOOK_KEY: ${FACEBOOK_KEY}
      FACEBOOK_SECRET: ${FACEBOOK_SECRET}
      VK_KEY: ${VK_KEY}
      VK_SECRET: ${VK_SECRET}
      GOOGLE_KEY: ${GOOGLE_KEY}
      GOOGLE_SECRET: ${GOOGLE_SECRET}
    volumes:
      - .:/pandora:cached
      - ./docker/app/main.sh:/main.sh:cached
    networks:
      - internal_network
    ports:
      - 4201:4201
    restart: always
    logging:
      driver: "json-file"
      options:
        max-size: ${LOG_MAX_SIZE}
        max-file: ${LOG_MAX_FILE}

  # event streaming service
  pubsub:
    depends_on:
      - nats
    build:
      context: ./
      dockerfile: ./docker/pubsub/Dockerfile
    container_name: pubsub
    environment:
      NATS_URI: ${NATS_URI}
    networks:
      - internal_network
    ports:
      - 4302:4302
    restart: always
    logging:
      driver: "json-file"
      options:
        max-size: ${LOG_MAX_SIZE}
        max-file: ${LOG_MAX_FILE}

  # web server - service gateway
  caddy:
    build:
      context: ./
      dockerfile: ./docker/caddy/Dockerfile
    container_name: caddy
    environment:
      CADDY_URLS: ${CADDY_URLS}
      HOSTNAME: ${HOSTNAME}
      HTTP_PORT: ${HTTP_PORT}
      HTTPS_PORT: ${HTTPS_PORT}
      DGRAPH_URL: http://dgraph:8080
      JWT_SECRET: ${JWT_SECRET}
      DGRAPH_TOKEN: ${DGRAPH_TOKEN}
      ADMIN_SECRET: ${ADMIN_SECRET}
      SYSTEM_PWD: ${SYSTEM_PWD}
      ADMIN_PWD: ${ADMIN_PWD}
      API_KEY: ${API_KEY}
      CADDYPATH: /data/caddy
    volumes:
      - caddy:/data/caddy
      - ./config/caddy/Caddyfile:/etc/Caddyfile:cached
    networks:
      - internal_network
    ports:
      - ${HTTP_PORT}:${HTTP_PORT}
      - ${HTTPS_PORT}:${HTTPS_PORT}
    restart: always
    logging:
      driver: "json-file"
      options:
        max-size: ${LOG_MAX_SIZE}
        max-file: ${LOG_MAX_FILE}

  # monitor
  autoheal:
    image: willfarrell/autoheal
    container_name: autoheal
    restart: on-failure
    networks:
      - internal_network
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    logging:
      driver: "json-file"
      options:
        max-size: ${LOG_MAX_SIZE}
        max-file: ${LOG_MAX_FILE}