docker-compose.yml

x-common-django:
  &default-common-django
  image: ${COMPOSE_PROJECT_NAME}/geonode:${GEONODE_BASE_IMAGE_VERSION}
  restart: unless-stopped
  env_file:
    - .env
  volumes:
    # - './src:/usr/src/project'  # Uncomment for local development
    - statics:/mnt/volumes/statics
    - geoserver-data-dir:/geoserver_data/data
    - backup-restore:/backup_restore
    - data:/data
    - tmp:/tmp
  depends_on:
    db:
      condition: service_healthy
    redis:
      condition: service_healthy
    memcached:
      condition: service_healthy

services:

  # Our custom django application. It includes Geonode.
  django:
    << : *default-common-django
    build:
      context: ./
      dockerfile: Dockerfile
    container_name: django4${COMPOSE_PROJECT_NAME}
    healthcheck:
      test: "curl -m 10 --fail --silent --output /dev/null http://django:8000/"
      start_period: 60s
      interval: 60s
      timeout: 10s
      retries: 2
    environment:
      - IS_CELERY=False
    entrypoint: ["/usr/src/project/entrypoint.sh"]
    command: "uwsgi --ini /usr/src/project/uwsgi.ini"

  # Celery worker that executes celery tasks created by Django.
  celery:
    << : *default-common-django
    container_name: celery4${COMPOSE_PROJECT_NAME}
    environment:
      - IS_CELERY=True
    entrypoint: ["/usr/src/project/entrypoint.sh"]
    command: "celery-cmd"
    healthcheck:
      test: "celery -b ${BROKER_URL} inspect ping"
      start_period: 30s
      interval: 30s
      timeout: 10s
      retries: 2

  # Nginx serving django static/media and proxies to django/geonode
  nginx:
    image: ${COMPOSE_PROJECT_NAME}/nginx:${NGINX_BASE_IMAGE_VERSION}
    build:
      context: ./docker/nginx
      dockerfile: Dockerfile
      args:
        - BASE_IMAGE_VERSION=${NGINX_BASE_IMAGE_VERSION}
    container_name: nginx4${COMPOSE_PROJECT_NAME}
    env_file:
      - .env
    environment:
      - RESOLVER=127.0.0.11
    ports:
      - "${HTTP_PORT}:80"
      - "${HTTPS_PORT}:443"
    volumes:
      - nginx-confd:/etc/nginx
      - nginx-certificates:/geonode-certificates
      - statics:/mnt/volumes/statics
    restart: unless-stopped
    healthcheck:
      test: "if ps -o pid | grep -w 1 > /dev/null; then echo 'nginx running'; else exit 1;fi"
      interval: 10s
      timeout: 5s
      retries: 3
      start_period: 10s

  # memcached service
  memcached:
    image: memcached:alpine
    container_name: memcached4${COMPOSE_PROJECT_NAME}
    command: memcached ${MEMCACHED_OPTIONS}
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "nc", "-z", "127.0.0.1", "11211"]
      interval: 30s
      timeout: 5s
      retries: 3
      start_period: 10s

  # Gets and installs letsencrypt certificates
  letsencrypt:
    image: ${COMPOSE_PROJECT_NAME}/letsencrypt:${LETSENCRYPT_BASE_IMAGE_VERSION}
    build:
      context: ./docker/letsencrypt
      dockerfile: Dockerfile
      args:
        - BASE_IMAGE_VERSION=${LETSENCRYPT_BASE_IMAGE_VERSION}
    container_name: letsencrypt4${COMPOSE_PROJECT_NAME}
    env_file:
      - .env
    volumes:
      - nginx-certificates:/geonode-certificates
    restart: unless-stopped
    depends_on:
      nginx:
        condition: service_healthy

  # Geoserver backend
  geoserver:
    image: ${COMPOSE_PROJECT_NAME}/geoserver:${GEOSERVER_BASE_IMAGE_VERSION}
    build:
      context: ./docker/geoserver
      dockerfile: Dockerfile
      args:
        - BASE_IMAGE_VERSION=${GEOSERVER_BASE_IMAGE_VERSION}
    container_name: geoserver4${COMPOSE_PROJECT_NAME}
    healthcheck:
      test: ["CMD", "curl", "-f", "http://geoserver:8080/geoserver/web/wicket/resource/org.geoserver.web.GeoServerBasePage/img/logo.png"]
      start_period: 30s
      interval: 30s
      timeout: 10s
      retries: 3
    env_file:
      - .env
    volumes:
      - statics:/mnt/volumes/statics
      - geoserver-data-dir:/geoserver_data/data
      - backup-restore:/backup_restore
      - data:/data
      - tmp:/tmp
    restart: unless-stopped
    depends_on:
      data-dir-conf:
        condition: service_healthy
      django:
        condition: service_healthy

  data-dir-conf:
    image: ${COMPOSE_PROJECT_NAME}/geoserver_data:${GEOSERVER_DATA_BASE_IMAGE_VERSION}
    build:
      context: ./docker/geoserver_data
      dockerfile: Dockerfile
      args:
        - BASE_IMAGE_VERSION=${GEOSERVER_DATA_BASE_IMAGE_VERSION}
    container_name: gsconf4${COMPOSE_PROJECT_NAME}
    entrypoint: sleep infinity
    volumes:
      - geoserver-data-dir:/geoserver_data/data
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "[ $$(ls -A /geoserver_data/data | wc -l) -gt 0 ] || exit 1"]
      interval: 10s
      timeout: 5s
      retries: 3

  # PostGIS database.
  db:
    image: ${COMPOSE_PROJECT_NAME}/postgis:${POSTGRES_BASE_IMAGE_VERSION}
    build:
      context: ./docker/postgresql
      dockerfile: Dockerfile
      args:
        - BASE_IMAGE_VERSION=${POSTGRES_BASE_IMAGE_VERSION}
    command: postgres -c "max_connections=${POSTGRESQL_MAX_CONNECTIONS}"
    container_name: db4${COMPOSE_PROJECT_NAME}
    env_file:
      - .env
    volumes:
      - dbdata:/var/lib/postgresql/data
      - dbbackups:/pg_backups
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -d postgres -U postgres"]
      interval: 10s
      timeout: 5s
      retries: 5
      # uncomment to enable remote connections to postgres
      #ports:
      #  - "5432:5432"

  # Vanilla Redis service. This is needed by celery
  redis:
    image: redis:7-alpine
    container_name: redis4${COMPOSE_PROJECT_NAME}
    volumes:
      - redisdata:/data
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 20s
      timeout: 3s
      retries: 3
      start_period: 5s

volumes:
  statics:
    name: ${COMPOSE_PROJECT_NAME}-statics
  nginx-confd:
    name: ${COMPOSE_PROJECT_NAME}-nginxconfd
  nginx-certificates:
    name: ${COMPOSE_PROJECT_NAME}-nginxcerts
  geoserver-data-dir:
    name: ${COMPOSE_PROJECT_NAME}-gsdatadir
  dbdata:
    name: ${COMPOSE_PROJECT_NAME}-dbdata
  dbbackups:
    name: ${COMPOSE_PROJECT_NAME}-dbbackups
  backup-restore:
    name: ${COMPOSE_PROJECT_NAME}-backup-restore
  data:
    name: ${COMPOSE_PROJECT_NAME}-data
  tmp:
    name: ${COMPOSE_PROJECT_NAME}-tmp
  redisdata:
    name: ${COMPOSE_PROJECT_NAME}-redisdata