docker-compose.prod.yml

version: '3.8'

networks:
  react-express:
  express-mongo:
  mongo-mongo:

#volumes:
#db-data:
#reactapp:
#expressapi:

services:
  # WIP - MVP - Integration of an 0Auth2 proxy

  # oauth2-proxy:
  # image: caarlos0/oauth2_proxy
  # ports:
  # - 127.0.0.1:4180:4180
  # command:
  # - '-client-id=123'
  # - '-client-secret=456'
  # - '-provider=github'
  # - '-github-org=caarlos0-m'
  # - '-email-domain=*'
  # - '-cookie-secret=foo bar 1234'
  # - '-cookie-secure=false'
  # - '-upstream=http://nginx:80'
  # - '-http-address=0.0.0.0:4180'
  # - '-redirect-url=http://m.carlosbecker.com/oauth2/callback'
  # - '-set-xauthrequest=true'

  # WIP - MVP - nginx-reverse-proxy:
  #nginx:
  #  image: nginx:1.21.5-alpine
  #  container_name: nginx
  #  restart: always
  #  ports:
  #    - 80:80
  #  volumes:
  #    - ./nginx/nginx-dev.conf:/etc/nginx/conf.d/default.conf
  #  depends_on:
  #    - api-dev
  #    - client-dev
  #  networks:

  # expose one service - on the port 80, and we mount our config file to the /etc/nginx/conf.d folder.
  # nginx will be the only thing facing the internet for real, and it will route traffic to the right places.

  #prometheus:
  #  image: prom/prometheus:v2.32.1
  #  container_name: prometheus
  #  volumes:
  #    - ./prometheus:/etc/prometheus
  #    - prometheus_data:/prometheus
  #  command:
  #    - '--config.file=/etc/prometheus/prometheus.yml'
  #    - '--storage.tsdb.path=/prometheus'
  #    - '--web.console.libraries=/etc/prometheus/console_libraries'
  #    - '--web.console.templates=/etc/prometheus/consoles'
  #    - '--storage.tsdb.retention.time=200h'
  #    - '--web.enable-lifecycle'
  #  restart: unless-stopped
  #  ports:
  #    - "9090:9090"
  #  #expose:
  #    #- 9090
  #  networks:
  #    - log-net
  #  labels:
  #   org.label-schema.group: "health,logging & monitoring"
  #

  #alertmanager:
  #  image: prom/alertmanager:v0.23.0
  #  container_name: alertmanager
  #  volumes:
  #    - ./alertmanager:/etc/alertmanager
  #  command:
  #    - '--config.file=/etc/alertmanager/config.yml'
  #    - '--storage.path=/alertmanager'
  #  restart: unless-stopped
  #  ports:
  #    - "9093:9093"
  #  #expose:
  #    #- 9093
  #  networks:
  #    - log-net
  #  labels:
  #    org.label-schema.group: "health,logging & monitoring"

  #nodeexporter:
  #  image: prom/node-exporter:v1.3.1
  #  #container_name: node-exporter
  #  #build:
  #    #dockerfile: Dockerfile
  #    #context: ./cineexporter/app
  #  #volumes:
  #    #- './cineexporter/app:/app'
  #    #- './cineexporter/app/node_modules'
  #  #image: prom/node-exporter:latest
  #  container_name: nodeexporter
  #  volumes:
  #    - /proc:/host/proc:ro
  #    - /sys:/host/sys:ro
  #    - /:/rootfs:ro
  #    #- /:/host:ro,rslave
  #  command:
  #    - '--path.procfs=/host/proc'
  #    - '--path.rootfs=/rootfs'
  #    #- '--path.rootfs=/host'
  #    - '--path.sysfs=/host/sys'
  #    - '--collector.filesystem.mount-points-exclude=^/(sys|proc|dev|host|etc)($$|/)'
  #  restart: unless-stopped
  #  #expose:
  #    #- 9100
  #  networks:
  #    - log-net
  #  labels:
  #    org.label-schema.group: "health,logging & monitoring"
  #  ports:
  #    - "9100:9100"

  # Let’s break this down. basically, we are telling Docker to use the current directory as a context
  # where to run everything and use the Dockerfile found in the local directory.
  # Then we are telling docker to name the image built reactapp_image and the container
  # reactapp_container We are also telling docker to map our local machines port 8000 to
  # the containers port 8000 . Then since we want all code changes we make locally to be reflected
  # in our prod server we are going to map our current directory to the containers /app directory
  # where our application runs in.

  # Parameters description

  #     db & graphql: Names of the services run by Docker Compose.
  #     container_name: Guess what? It’s the container name!
  #     image: Name of the image to use to run the container.
  #     build: When a build context is provided, Docker Compose will build a custom image using the Dockerfile located in the context folder.
  #     context: Indicates the folder where to find the Dockerfile to build the image.
  #     volumes: Mapping between the project folder on your host machine and the PostgreSQL folder in your container, in format host_folder:container_folder. All the files generated in the container_folder will be copied in the host_folder so that you can preserve and retrieve your data when stopping/restarting the container. Replace the host folder by the destination of your choice. If it does not exist it will be automatically created.
  #     environment: Environment variables for the container. POSTGRES_PASSWORD sets the password of PostgreSQL superuser. Value is 1234 in the example above but you should pick a stronger password of your choice. This variable should not be written in the docker-compose file but rather in a .env file which must not be committed in your Git repository.
  #     expose: Port number of the container to be exposed to the outside.
  #     ports: Port, mapping between the port of your host machine and the port of your container, in format host_port:container_port.
  #     networks: Networks are used to group and connect containers as part of a same network.
  #     command: Command to be executed after the container starts. Each argument must be provided in a separate list item.

  #    Ports mentioned in docker-compose.yml will be shared among different services started by the docker-compose.
  #    Ports will be exposed to the host machine to a random port or a given port.

  #    Expose ports without publishing them to the host machine - they’ll only be accessible to linked services. Only the internal port can be specified.
  #    Ports are not exposed to host machines, only exposed to other services.

  frontend:
    build: ${FRONTEND_PATH}app/Dockerfile.prod
    restart: always
    stdin_open: true
    image: frontend-image
    container_name: frontend-image
    ports:
      - 3002:3002
    #The React development server will be running inside the container and will be watching the src folder.
    volumes:
      - ./frontend/app:/usr/src/app
      - /usr/src/app/node_modules
    #links:
    #    - express
    env_file:
      - .env
    environment:
      #React specific....
      - CHOKIDAR_USEPOLLING=true
    #depends_on:
    #  -  express-api
    depends_on:
      - backend
    networks:
      - react-express

  backend:
    #build:
    #  context: ${BACKEND_PATH}todoapp-express-backend/app/
    #  dockerfile: ${BACKEND_PATH}todoapp-express-backend/app/Dockerfile
    container_name: backend
    restart: always
    build: ${BACKEND_PATH}todoapp-express-backend/app/Dockerfile.prod
    volumes:
      - ./backend/app:/usr/src/app
      - /usr/src/app/node_modules
    ports:
      - 4000:4000
      #depends_on:
      # - mongodb
      #  ENVIRONMET_VARIABLE_NAME: "environment variable value"
    environment:
      - mongoURI=mongodb://mongodb:27017/restAPI
    depends_on:
      - mongo-db
    networks:
      - express-mongo
      - react-express

  mongo-db:
    container_name: mongo
    restart: always
    image: mongo:4.4.13
    ports:
      - 27017:27017
      # ENVIRONMET_VARIABLE_NAME: "environment variable value"
    env_file:
      - .env
    environment:
      - MONGO_INITDB_ROOT_USERNAME=${MONGO_ROOT_USER}
      - MONGO_INITDB_ROOT_PASSWORD=${MONGO_ROOT_PASSWORD}
    volumes:
      - ./data:/data/db
    networks:
      - express-mongo
    expose:
      - 27017

  mongo-express:
    image: mongo-express
    container_name: mongo-express
    ports:
      - 8081:8081
    environment:
      - ME_CONFIG_MONGODB_ADMINUSERNAME=${MONGOEXPRESS_LOGIN}
      - ME_CONFIG_MONGODB_ADMINPASSWORD=${MONGOEXPRESS_PASSWORD}
      - ME_CONFIG_MONGODB_SERVER=mongodb
    depends_on:
      - mongo-db
    networks:
      - mongo-mongo

  mongo-seed:
    image: stefanwalther/mongo-seed
    container_name: mongo-seed
    environment:
      - MONGODB_HOST=mongo
      - MONGODB_PORT=27017
    volumes:
      - ./data:/data/db
    depends_on:
      - mongo-db
    networks:
      - mongo-mongo
    command:
      [
        'mongoimport --host mongo --port 27017 --db sammlerio --mode upsert --type json --file /data/auth-service~~user.json --jsonArray',
      ]