docker-compose.yml

version: '3.8'

services:
    ## Section for database and external tools

    # Database for grafana
    influxdb:
        build: docker-influxdb
        env_file: ./docker-influxdb/configuration.env
        ports:
          - '8086:8086'
        volumes:
          - influxdb_data:/var/lib/influxdb

    # UI for influxdb
    chronograf:
        image: chronograf:1.9
        command:
            - --influxdb-url=http://influxdb:8086
        ports:
          - '8888:8888'

    # Grafana, used here to show sensors graphs
    grafana:
        build: docker-grafana
        env_file: ./docker-grafana/configuration.env
        links:
          - influxdb
        ports:
          - '3000:3000'
        volumes:
          - grafana_data:/var/lib/grafana

    # Genaral purpose database
    mongo:
        image: mongo:4.4.5-bionic
        hostname: mongodb
        ports:
            - '27017:27017'
        environment:
            - MONGO_REPLICA_SET_NAME=dan
        command:
            - --storageEngine
            - wiredTiger
            - --replSet
            - myrepl
        healthcheck:
            test: test $$(echo "rs.initiate().ok || rs.status().ok" | mongo  --quiet) -eq 1
            interval: 10s
            start_period: 30s


    # admin credentials are admin:pass, change them
    mongo-express:
        image: mongo-express:latest
        container_name: mongo-express
        environment:
          ME_CONFIG_MONGODB_SERVER: mongo
        ports:
          - "8081:8081"
        depends_on:
          - mongo


    # Redis server, used here for caching
    # uses healthcheck with redis-cli ping
    redis:
        build:
            context: ./docker-redis
        ports:
            - '6379:6379'
        healthcheck:
              test: ["CMD", "redis-cli", "ping"]
              interval: 10s
              timeout: 3s
              start_period: 30s

    # Mosquitto MQTT broker
    mqtt:
        build:
          context: ./docker-mosquitto
        ports:
            - "1883:1883"

    # An api gateway
    krakend:
        image: devopsfaith/krakend
        volumes:
            - ${PWD}/krakend.json:/etc/krakend/krakend.json
        ports:
            - "8080:8080"
        depends_on:
            - web-random
            - web-users


    # Section for our containers

    # generates random numbers and lists them
    # uses healthcheck by making a curl request to a GET endpoint
    web-random:
        build:
            context: ./docker-python
            args:
                requirements: /root/flask-mongodb-example/python/requirements.txt
        ports:
            - "800:5000"
        entrypoint: python /root/flask-mongodb-example/python/random/random_demo.py
        depends_on:
            - mongo
        healthcheck:
            test: curl --silent --show-error --fail "http://localhost:5000/random?lower=0&upper10"
            interval: 10s
            start_period: 30s

    # generates random numbers and lists them, it's faster thatn web-random because it's using pypy accelerator
    web-random-pypy:
        build:
            context: ./docker-python-pypy
            args:
                requirements: /root/flask-mongodb-example/python/requirements.txt
        ports:
            - "801:5000"
        entrypoint: pypy /root/flask-mongodb-example/python/random/random_demo.py
        depends_on:
            - mongo

    # Create, read, update and delete operations over a user collection
    web-users:
        build:
            context: ./docker-python
            args:
                requirements: /root/flask-mongodb-example/python/requirements.txt
        ports:
            - "81:5000"
        entrypoint: python /root/flask-mongodb-example/python/users/users.py
        environment:
            - REDIS_PASSWORD=/run/secrets/redis_password
            - PYTHONUNBUFFERED=1
        secrets:
            - redis_password
        depends_on:
            - mongo
            - redis

    # Uses an MQTT server (Mosquitto) to allow to publish sensor updates over MQTT
    background-mqtt:
        build:
            context: ./docker-python
            args:
                requirements: /root/flask-mongodb-example/python/mqtt/requirements-mqtt.txt
        entrypoint: python /root/flask-mongodb-example/python/mqtt/mqtt.py
        environment:
            - MQTT_USER=/run/secrets/mqtt_user
            - MQTT_PASSWORD=/run/secrets/mqtt_password
            - PYTHONUNBUFFERED=1
        secrets:
            - mqtt_user
            - mqtt_password
        depends_on:
            - mongo
            - mqtt
            - influxdb
        tty: true

    # Fulltext search engine backed by fulltext MongoDb index
    web-fulltext-search:
        build:
            context: ./docker-python
            args:
                requirements: /root/flask-mongodb-example/python/requirements.txt
        ports:
            - "82:5000"
        entrypoint: python /root/flask-mongodb-example/python/fulltextsearch/fulltext_search.py
        depends_on:
            - mongo

    # Geospacial search service that supports adding places, and quering the placing by coordonates and distance
    web-geolocation-search:
        build:
            context: ./docker-python
            args:
                requirements: /root/flask-mongodb-example/python/geolocation/requirements-geolocation.txt
        ports:
            - "83:5000"
        entrypoint: python /root/flask-mongodb-example/python/geolocation/geolocation_search.py
        depends_on:
            - mongo

    # Baesian average demo (https://en.wikipedia.org/wiki/Bayesian_average)
    web-baesian:
        build:
            context: ./docker-python
            args:
                requirements: /root/flask-mongodb-example/python/requirements.txt
        ports:
            - "84:5000"
        entrypoint: python /root/flask-mongodb-example/python/baesian/baesian.py
        depends_on:
            - mongo

    # A demo of working with file photo uploads, hash searching and using docker volumes
    web-photo-process:
        build:
            context: ./docker-python
            args:
                requirements: /root/flask-mongodb-example/python/photo/requirements-photo.txt
        ports:
            - "85:5000"
        entrypoint: python /root/flask-mongodb-example/python/photo/photo_process.py
        volumes:
            - ./container-storage:/root/storage
        depends_on:
            - mongo

    # A virtual book library
    web-book-collection:
        build:
            context: ./docker-python
            args:
                requirements: /root/flask-mongodb-example/python/bookcollection/requirements.txt
        environment:
             - PYTHONUNBUFFERED=1
        ports:
            - "86:5000"
        entrypoint: python /root/flask-mongodb-example/python/bookcollection/bookcollection.py
        depends_on:
            - mongo
            - web-users

    # Wame functionality as web-users but build with fastapi
    # runs with gunicorn on two processor cores [-w 2]
    web-users-fast-api:
        build:
            context: ./docker-python
            args:
                requirements: /root/flask-mongodb-example/python/fastapidemo/requirements.txt
        ports:
            - "88:5000" # port 87 is restricted in browsers
        entrypoint: gunicorn -w 2 -k uvicorn.workers.UvicornH11Worker --chdir /root/flask-mongodb-example/python/fastapidemo --bind 0.0.0.0:5000 --log-level debug users-fastapi:app
        depends_on:
            - mongo

    # A two player tic tac toe game written in flask using flask_session. It has a simple UI
    web-tictactoe:
        build:
            context: ./docker-python
            args:
                requirements: /root/flask-mongodb-example/python/requirements.txt
        ports:
            - "89:5000"
        entrypoint: python /root/flask-mongodb-example/python/tictactoe/tictactoe.py


    # GraphQl implementation of CRUD users
    web-users-graphql:
        build:
            context: ./docker-python
            args:
                requirements: /root/flask-mongodb-example/python/graphql/requirements.txt
        ports:
            - "90:5000"
        entrypoint: python /root/flask-mongodb-example/python/graphql/users.py

    # Used to test build of services
    web-test:
        image: alpine
        depends_on:
            - web-random
            - web-random-pypy
            - web-users
            - background-mqtt
            - web-fulltext-search
            - web-geolocation-search
            - web-baesian
            - web-photo-process
            - web-book-collection
            - web-users-fast-api
            - web-users-graphql
            - influxdb
            - chronograf
            - grafana
            - mongo
            - mqtt
            - krakend
            - web-tictactoe
            - redis

volumes:
    grafana_data: {}
    influxdb_data: {}

secrets:
    mqtt_user:
        file: ./secrets/mqtt_user.txt
    mqtt_password:
        file: ./secrets/mqtt_pass.txt
    redis_password:
        file: ./secrets/redis_pass.txt

networks:
  default:
    name: project-network
    external: true