docker-compose-gke.yaml

version: '3.7'

services:

  # Website Microservice
  # This is the website arclytics.io container that can be deployed to
  # a Kubernetes service.
  website:
    build:
      context: ./arclytics.io/client/
      dockerfile: Dockerfile
      args:
        - NODE_ENV=production
      labels:
        arclytics.io: "production"
        service: "website"
    image: gcr.io/arclytics/arc_sim_website:latest
    ports:
      - 8080:8080
    expose:
      - 8080

  # Fluentd Microservice
  # This is the `fluentd` logger container that ingests all logs from Docker and
  # acts as a centralised logging layer.
  fluentd:
    build:
      context: ./services/fluentd
      dockerfile: Dockerfile-prod
      labels:
        arclytics.io: "production"
        service: "fluentd"
    image: gcr.io/arclytics/arc_fluentd:latest
    restart: always
    ports:
      - 24224:24224
      - 24224:24224/udp
      - 9880:9880
    expose:
      - 24224
      - 9880

  # Client Microservice
  # This is the React front-end container that the client can access via the
  # Nginx HTTP server. This container is built in production mode and it is
  # the static files are copied to a Nginx HTTP server container.
  client:
    build:
      context: ./services/client
      dockerfile: Dockerfile-prod
      args:
        - NODE_ENV=production
        - REACT_APP_SIM_HOST=https://api.arclytics.io
        - REACT_APP_SIM_PORT=443
        - REACT_APP_ARC_HOST=https://api.arclytics.io
        - REACT_APP_ARC_PORT=443
        - REACT_APP_FLUENTD_URL=https://app.arclytics.io/logger
      labels:
        arclytics.io: "production"
        service: "client"
    image: gcr.io/arclytics/arc_sim_client:2.0.0
    ports:
      - 8080:8080
    expose:
      - 8080
    environment:
      - NODE_ENV=production
      - REACT_APP_SIM_HOST=https://api.arclytics.io
      - REACT_APP_SIM_PORT=443
      - REACT_APP_ARC_HOST=https://api.arclytics.io
      - REACT_APP_ARC_PORT=443
      - REACT_APP_FLUENTD_URL=https://app.arclytics.io/logger

  # SimCCT Microservice
  # This is the main service that provides user and admin management, authentication,
  # authorization, server-side session and cookie management, and the RESTful API
  # for the `arc_simulation` package. The `arc_simulation` package is a submodule
  # that provides the algorithm for phase transformation calculations. This service
  # is written with the Flask microframework and contains additional Flask plugins
  # provided by the open-source community.
  simcct:
    build:
      context: ./services/simcct
      dockerfile: Dockerfile-prod
      labels:
        arclytics.io: "production"
        service: "simcct"
    image: gcr.io/arclytics/arc_sim_service:2.0.0
    ports:
      - 8000:8000
    expose:
      - 8000
    environment:
      - FLASK_APP=sim_api/__init__.py
      - FLASK_ENV=production
      - APP_SETTINGS=configs.flask_conf.ProductionConfig
      - SECRET_KEY=${SECRET_KEY}
      - SECURITY_PASSWORD_SALT=${SECURITY_PASSWORD_SALT}
      - MONGO_HOST=mongo-service
      - MONGO_PORT=27017
      - MONGO_APP_DB=${MONGO_APP_DB}
      - MONGO_APP_USER=${MONGO_APP_USER}
      - MONGO_APP_USER_PASSWORD=${MONGO_APP_USER_PASSWORD}
      - REDIS_HOST=redis-service
      - REDIS_PORT=6379
      - REDIS_PASSWORD=${REDIS_PASSWORD}
      - CLIENT_SCHEME=https
      - CLIENT_HOST=app.arclytics.io
      - CLIENT_PORT=443
      - FLUENTD_HOST=fluentd-service
      - FLUENTD_PORT=24224
      - FLUENTD_PREFIX_TAG=simcct
      - ELASTIC_APM_SERVER_URL=http://apm-service:8200
      - ELASTIC_APM_SECRET_TOKEN=${SECRET_TOKEN}

  # Celery-Worker Microservice
  # This container contains a Flask instance of a Celery worker node that performs
  # asynchronous tasks based on the message queue from Redis and stores the result
  # in the Redis backend.
  celery-worker:
    build:
      context: ./services/celery-worker
      dockerfile: Dockerfile-prod
      labels:
        arclytics.io: "production"
        service: "celery-worker"
    image: gcr.io/arclytics/arc_sim_celery:2.0.0
    ports:
      - 5555:5555
    expose:
      - 5555
    environment:
      - FLASK_ENV=production
      - APP_SETTINGS=flask_conf.ProductionConfig
      - MAIL_SERVER=${MAIL_SERVER}
      - MAIL_PORT=${MAIL_PORT}
      - MAIL_USE_TLS=${MAIL_USE_TLS}
      - MAIL_USERNAME=${MAIL_USERNAME}
      - MAIL_PASSWORD=${MAIL_PASSWORD}
      - MONGO_HOST=mongo-service
      - MONGO_PORT=27017
      - MONGO_APP_DB=arclytics
      - MONGO_APP_USER=${MONGO_APP_USER}
      - MONGO_APP_USER_PASSWORD=${MONGO_APP_USER_PASSWORD}
      - REDIS_HOST=redis-service
      - REDIS_PORT=6379
      - REDIS_PASSWORD=${REDIS_PASSWORD}
      - ELASTIC_APM_SERVER_URL=http://apm-service:8200
      - ELASTIC_APM_SECRET_TOKEN=${SECRET_TOKEN}

  # Arclytics Microservice
  # This is the container that provides analytics for the application. It ensures
  # authentication and authorization by using the same secret key as the `simcct`
  # microservice and decoding the JSON Web Token that is set in the cookie.
  # This service is written with the Flask microframework and contains additional
  # Flask plugins provided by the open-source community.
  arclytics:
    build:
      context: ./services/arclytics
      dockerfile: Dockerfile-prod
      labels:
        arclytics.io: "production"
        service: "arclytics"
    image: gcr.io/arclytics/arclytics_service:2.0.0
    ports:
      - 8001:8001
    expose:
      - 8001
    environment:
      - FLASK_APP=arc_api/__init__.py
      - FLASK_ENV=production
      - APP_SETTINGS=configs.flask_conf.ProductionConfig
      - SECRET_KEY=${SECRET_KEY}
      - SIMCCT_HOST=http://simcct-service:8000/v1/sim
      - REDIS_HOST=redis-service
      - REDIS_PORT=6379
      - REDIS_PASSWORD=${REDIS_PASSWORD}
      - MONGO_HOST=mongo-service
      - MONGO_PORT=27017
      - MONGO_APP_DB=arc_dev
      - MONGO_APP_USER=${MONGO_APP_USER}
      - MONGO_APP_USER_PASSWORD=${MONGO_APP_USER_PASSWORD}
      - FLUENTD_HOST=fluentd-service
      - FLUENTD_PORT=24224
      - FLUENTD_PREFIX_TAG=arclytics
      - ELASTIC_APM_SERVER_URL=http://apm-server:8200
      - MAPBOX_TOKEN=${MAPBOX_TOKEN}

  # Redis Microservice
  # This is a Redis in-memory data store and persistence layer than is used by other
  # services including `simcct`, `arclytics`, and `celery-worker`. It's main purpose
  # is for the server-side session storage for Flask and the message queue and results
  # backend for Celery.
  redis:
    build:
      context: ./services/redis
      dockerfile: Dockerfile-prod
      labels:
        arclytics.io: "production"
        service: "redis"
    image: gcr.io/arclytics/arc_sim_redis:latest
    restart: always
    ports:
      - 6379:6379
    expose:
      - 6379
    environment:
      - REDIS_PASSWORD=${REDIS_PASSWORD}

  # MongoDB Microservice
  # MongoDB is an open-source, general purpose, document-based, distributed
  # NoSQL database. Our application uses MongoDB with a Replica Set distribution
  # as the data persistence layer for our users and application data. We also
  # use MongoDB’s querying language and pipelines to leverage data analytics
  # about our users, application, and the simulation data.
  mongodb:
    build:
      context: ./services/db
      dockerfile: Dockerfile-prod
      labels:
        arclytics.io: "production"
        service: "mongodb"
    image: gcr.io/arclytics/arc_sim_mongo:latest
    restart: always
    ports:
      - 27017:27017
    expose:
      - 27017
    environment:
      - MONGO_INITDB_ROOT_USERNAME=${MONGO_ROOT_USER}
      - MONGO_INITDB_ROOT_PASSWORD=${MONGO_ROOT_PASSWORD}
      - MONGO_ROOT_USER=${MONGO_ROOT_USER}
      - MONGO_ROOT_PASSWORD=${MONGO_ROOT_PASSWORD}
      - MONGO_APP_DB=${MONGO_APP_DB}
      - MONGO_APP_USER=${MONGO_APP_USER}
      - MONGO_APP_USER_PASSWORD=${MONGO_APP_USER_PASSWORD}
      - MONGO_DATA_DIR=/usr/data/db
      - MONGO_LOG_DIR=/dev/null