docker-compose.yml

version: "3.9"

volumes:
  postgres_data:
  certificates:
  static-data:
  media-data:
  minio_images:
services:
  db:
    image: kartoza/postgis:16-3.4
    volumes:
      - postgres_data:/var/lib/postgresql
    environment:
      - POSTGRES_DB=${POSTGIS_DB:-minisass_data}
      - POSTGRES_USER=${POSTGRES_USER:-docker}
      - POSTGRES_PASS=${POSTGRES_PASS:-docker}
      - ALLOW_IP_RANGE=${ALLOW_IP_RANGE:-0.0.0.0/0}
      - POSTGRES_MULTIPLE_EXTENSIONS=${POSTGRES_MULTIPLE_EXTENSIONS:-postgis,hstore,postgis_topology,postgis_raster,pgrouting}
      - FORCE_SSL=${FORCE_SSL:-FALSE}
    ports:
      - "32769:5432"
    restart: always
    healthcheck:
      test: "PGPASSWORD=${POSTGRES_PASS} pg_isready -h 127.0.0.1 -U ${POSTGRES_USER} -d minisass_data"
      interval: 5s
      timeout: 10s
      retries: 30

  minio:
    image: quay.io/minio/minio
    environment:
      - MINIO_ROOT_USER=${MINIO_ROOT_USER}
      - MINIO_ROOT_PASSWORD=${MINIO_ROOT_PASSWORD}
    entrypoint: /bin/bash
    command: -c 'minio server /data --console-address ":9001"'
    volumes:
      - minio_images:/data
    ports:
      - "9000:9000"
      - "9001:9001"
    healthcheck:
      test: [ "CMD", "curl", "-f", "http://localhost:9000/minio/health/live" ]
      interval: 30s
      timeout: 20s
      retries: 3

  createbuckets:
    image: minio/mc
    depends_on:
      minio:
        condition: service_started
    entrypoint: >
      /bin/sh -c "
      /usr/bin/mc config host add minisass http://minio:9000 ${MINIO_ROOT_USER} ${MINIO_ROOT_PASSWORD};
      /usr/bin/mc rm -r --force minisass/${BUCKET};
      /usr/bin/mc mb minisass/${BUCKET};
      /usr/bin/mc policy download minisass/${BUCKET};
      exit 0;
      "

  # mount:
  #   image: kartoza/s3mount
  #   build:
  #     context: deployment/docker-s3-bucket
  #   privileged: true
  #   environment:
  #     - AWS_ACCESS_KEY=${MINIO_ROOT_USER}
  #     - AWS_SECRET_ACCESS_KEY=${MINIO_ROOT_PASSWORD}
  #     - S3_MOUNT_DIRECTORY=/web
  #     - S3_BUCKET_NAME=${BUCKET}
  #     # URL can be an amazon S3 bucket so that we can mount it
  #     - MINIO_URL=http://minio:9000/
  #   volumes:
  #     - minio_images:/web
  #   depends_on:
  #     minio:
  #       condition: service_started

  # Build failed with the service above, so I replaced with a custom image as documented on https://kartoza.github.io/miniSASS/developer/install/#installation-steps:~:text=of%20your%20choice.-,Optional,-%3A%20Adjust%20the%20build
  mount:
    image: kartoza/s3mount
    build:
      context: .
      dockerfile: ./deployment/docker-s3-bucket/Dockerfile

  django:
    build:
      context: .
      dockerfile: ./deployment/docker/Dockerfile
    volumes:
      - static-data:/home/web/static
      - media-data:/home/web/media
      - ./django_project:/home/web/django_project
      # Images on the platform will be stored here
      - minio_images:/home/web/minio
    environment:
      - AWS_ACCESS_KEY=${MINIO_ROOT_USER:-minisass_admin}
      - AWS_SECRET_ACCESS_KEY=${MINIO_ROOT_PASSWORD:-secure_minio_secret}
      - DJANGO_DB=${POSTGRES_DB:-minisass_data}
      - POSTGRES_USER=${POSTGRES_USER:-docker}
      - POSTGRES_PASS=${POSTGRES_PASS:-docker}
      - DATABASE_HOST=${DATABASE_HOST:-db}
      - DATABASE_PORT=${DATABASE_PORT:-5432}
      - SENTRY_KEY=${SENTRY_KEY:-}
      - MINIO_ROOT=/home/web/minio
      - MINIO_BUCKET=${BUCKET:-demo}
      - MINIO_ACCESS_KEY=${MINIO_ROOT_USER:-minisass_admin}
      - MINIO_SECRET_KEY=${MINIO_ROOT_PASSWORD:-secure_minio_secret}
      - MINIO_AI_BUCKET=${BUCKET}
      # Not used in the code. 
      - MINIO_ENDPOINT=${MINIO_URL:-http://minio:9000}
      - MINIO_URL=${MINIO_URL:-http://minio:9000}
      - ALLOWED_HOSTS='*'
      - DEV_SETUP=${DEV_SETUP}
      - GOOGLE_ANALYTICS_TRACKING_CODE=${GOOGLE_ANALYTICS_TRACKING_CODE}
    depends_on:
      db:
        condition: service_healthy
    restart: always
    ports:
      - "8080"
    logging:
      driver: json-file
      options:
        max-size: 200m
        max-file: '10'

  letsencrypt:
    build: ./deployment/letsencrypt/
    environment:
      - HTTPS_HOST=${HTTPS_HOST}
      - HTTP_HOST=${HTTP_HOST}
      - ADMIN_EMAIL=${ADMIN_EMAIL}
      - LETSENCRYPT_MODE=${LETSENCRYPT_MODE}
    volumes:
      - certificates:/certificates/
    restart: always

  tiles:
    image: pramsey/pg_tileserv
    volumes:
      - ./deployment/config/pg_tileserv.toml:/etc/pg_tileserv.toml
    restart: always
    environment:
      - DATABASE_URL=postgres://${POSTGRES_USER}:${POSTGRES_PASS}@${DATABASE_HOST}/${POSTGRES_DB}
      - TS_URLBASE=${VECTOR_TILES_URL}
      - TS_BASEPATH=/tiles
    depends_on:
      db:
        condition: service_healthy
    healthcheck:
      test: curl --fail -s http://localhost:9000/ || exit 1
      interval: 1m30s
      timeout: 10s
      retries: 3
    logging:
      driver: json-file
      options:
        max-size: 200m
        max-file: '10'

  web:
    image: nginx
    hostname: nginx
    environment:
      - HTTPS_HOST=${HTTPS_HOST}
      - HTTP_HOST=${HTTP_HOST}
      - HTTPS_PORT=${HTTPS_PORT}
      - HTTP_PORT=${HTTP_PORT}
      - LETSENCRYPT_MODE=${LETSENCRYPT_MODE}
      - RESOLVER=${RESOLVER}
    ports:
      - "61122:80"
    volumes:
      - ./deployment/nginx/sites-enabled:/etc/nginx/conf.d:ro
      - static-data:/home/web/static
      - media-data:/home/web/media
      - minio_images:/home/web/minio
      - certificates:/certificates/
    restart: on-failure
    depends_on:
      - django
      - db
    logging:
      driver: json-file
      options:
        max-size: 200m
        max-file: '10'