Enabling under Traefik example?

[davekeeshan]

Is there an example of plane running under traefik.

I have a cloud server up and running with a wordpress instance and a few other small services already working. I want to add plane to this list.

I can start plane from docker compose (outside the setup.sh script) and it works is I ssh in and port forward to localhost.

However when I try and get plane to run under a subdomain i have if doesn't work. I do get some landing page, but it is just a spinning wheel. So far I have commented out the proxy part of the docker-compose.yml file and added these lines:

networks:
  traefik:
    external: true

And, which ${PLANE_DOMAIN} is an environment variable:

networks:
  - traefik
labels:
  # The labels are usefull for Traefik only
  - "traefik.enable=true"
  - "traefik.docker.network=traefik"
  # Get the routes from http
  - traefik.http.routers.plane.rule=Host(`${PLANE_DOMAIN}`)
  - "traefik.http.routers.plane.entrypoints=web"
  # Redirect these routes to https
  - "traefik.http.middlewares.redirect-to-https.redirectscheme.scheme=https"
  - "traefik.http.routers.plane.middlewares=redirect-to-https@docker"
  # Get the routes from https
  - traefik.http.routers.plane-secured.rule=Host(`${PLANE_DOMAIN}`)
  - "traefik.http.routers.plane-secured.entrypoints=web-secure"
  # Apply autentificiation with http challenge
  - "traefik.http.routers.plane-secured.tls=true"
  - "traefik.http.routers.plane-secured.tls.certresolver=myhttpchallenge"

This works in other micro services, but not here, what am I missing?

Have have also set

WEB_URL, CORS_ALLOWED_ORIGINS, NEXT_PUBLIC_DEPLOY_URL in the .env script to reflect my subdomain path

[davekeeshan]

I am not too sure if anyone has looked at this, but i think you need to enable api as well as web.

However I think I have run into problems now due to strict-origin-when-cross-origin errors, traefik needs to be setup for CORS.

Anyway I am stuck here now, but I think i have pushed the problem up the hill a little bit.

[mguptahub]

Hello @davekeeshan

Check the sample docker compose with traefix implementation. traefik.sample.yaml.txt

This can give you a start in terms of service & the ports required.

[davekeeshan]

@mguptahub That is interesting, there were more things to set than I realised.

However it does not work for me, one is that I want it to be working for a domain name, not localhost (not much point putting it behind traefik). I think I made the required changes, but it still hangs, and i think it is CORS related:

[davekeeshan]

@mguptahub bump!

Does anybody check these forums or is discord where all the work happens?

[vansergen]

You can try the following setup to make it work with an external domain (https://plane.example.com)

• compose.yaml

services:
  traefik:
    image: traefik:v3.0
    restart: unless-stopped
    container_name: traefik
    ports:
      - 80:80
      - 443:443
    volumes:
      - letsencrypt:/letsencrypt
      - ./traefik/:/etc/traefik/
    networks:
      - web

  postgresql:
    image: postgres:16-alpine
    restart: unless-stopped
    container_name: postgresql
    env_file:
      - postgresql.env
    volumes:
      - postgresql:/var/lib/postgresql/data
    networks:
      - local

  redis:
    image: redis:7-alpine
    restart: unless-stopped
    container_name: redis
    volumes:
      - redis:/data
    networks:
      - local

  minio:
    image: quay.io/minio/minio
    restart: unless-stopped
    command: server /data --console-address ":9090"
    env_file:
      - minio.env
    container_name: minio
    volumes:
      - minio:/data
    networks:
      - web
      - local

  plane-frontend:
    image: makeplane/plane-frontend:stable
    container_name: plane-frontend
    pull_policy: always
    restart: unless-stopped
    env_file:
      - plane.env
    command: node web/server.js web
    depends_on:
      - plane-backend
      - plane-worker
    networks:
      - web

  plane-space:
    image: makeplane/plane-space:stable
    container_name: plane-space
    pull_policy: always
    restart: unless-stopped
    env_file:
      - plane.env
    command: node space/server.js space
    depends_on:
      - plane-backend
      - plane-worker
      - plane-frontend
    networks:
      - web
      - local

  plane-admin:
    image: makeplane/plane-admin:stable
    container_name: plane-admin
    pull_policy: always
    restart: unless-stopped
    env_file:
      - plane.env
    command: node admin/server.js admin
    depends_on:
      - plane-backend
      - plane-frontend
    networks:
      - web

  plane-backend:
    image: makeplane/plane-backend:stable
    container_name: plane-backend
    pull_policy: always
    restart: unless-stopped
    env_file:
      - plane.env
    command: ./bin/docker-entrypoint-api.sh
    depends_on:
      - postgresql
      - redis
    networks:
      - web
      - local

  plane-worker:
    image: makeplane/plane-backend:stable
    container_name: plane-worker
    pull_policy: always
    restart: unless-stopped
    env_file:
      - plane.env
    command: ./bin/docker-entrypoint-worker.sh
    depends_on:
      - plane-backend
      - postgresql
      - redis
    networks:
      - local

  plane-beat-worker:
    image: makeplane/plane-backend:stable
    container_name: plane-beat-worker
    pull_policy: always
    restart: unless-stopped
    env_file:
      - plane.env
    command: ./bin/docker-entrypoint-beat.sh
    depends_on:
      - plane-backend
      - postgresql
      - redis
    networks:
      - local

  plane-migrator:
    image: makeplane/plane-backend:stable
    container_name: plane-migrator
    pull_policy: always
    restart: no
    env_file:
      - plane.env
    command: ./bin/docker-entrypoint-migrator.sh
    depends_on:
      - postgresql
      - redis
    networks:
      - local

networks:
  web:
  local:

volumes:
  letsencrypt:
  postgresql:
  redis:
  minio:

• plane.env

# Gunicorn Workers
GUNICORN_WORKERS=2
# Secret Key
SECRET_KEY=<SUPER_SECRET_KEY>
# Don't use in production
DEBUG=0
# CORS
CORS_ALLOWED_ORIGINS=https://plane.example.com
# Database
DATABASE_URL=postgresql://<USERNAME>:<PASSWORD>@postgresql/plane
# Redis
REDIS_URL=redis://redis:6379/
# AWS S3
AWS_ACCESS_KEY_ID=<MINIO_USER>
AWS_SECRET_ACCESS_KEY=<MINIO_PASSWORD>
AWS_S3_BUCKET_NAME=plane
AWS_REGION=us-east-1
AWS_S3_ENDPOINT_URL=http://minio:9000
# URLs
WEB_URL=https://plane.example.com
#SPACE_BASE_URL=https://plane.example.com/spaces/
#ADMIN_BASE_URL=https://plane.example.com/god-mode/
# EMAIL SETTINGS
EMAIL_HOST=smtp.gmail.com
EMAIL_HOST_USER=<EMAIL>
EMAIL_HOST_PASSWORD=<PASSWORD>
EMAIL_PORT=587
EMAIL_FROM=no-reply
EMAIL_USE_TLS=1
EMAIL_USE_SSL=0
# LOGIN/SIGNUP SETTINGS
ENABLE_SIGNUP=1
ENABLE_EMAIL_PASSWORD=1
ENABLE_MAGIC_LINK_LOGIN=0
# GitHub
#GITHUB_CLIENT_ID=
#GITHUB_CLIENT_SECRET=
#GITHUB_APP_NAME=plane
# Google
#GOOGLE_CLIENT_ID=

• postgresql.env

POSTGRES_USER=<USERNAME>
POSTGRES_PASSWORD=<PASSWORD>
POSTGRES_DB=plane
PGDATA=/var/lib/postgresql/data

• minio.env

MINIO_ROOT_USER=<MINIO_USER>
MINIO_ROOT_PASSWORD=<MINIO_PASSWORD>

• traefik/traefik.yaml

entryPoints:
  web:
    address: :80
    http:
      redirections:
        entryPoint:
          to: websecure
          scheme: https
  websecure:
    address: :443

certificatesresolvers:
  http_resolver:
    acme:
      httpchallenge:
        entrypoint: web
      email: <YOUR_EMAIL>
      storage: /letsencrypt/acme.json

providers:
  file:
    directory: /etc/traefik/dynamic
    watch: true

• traefik/dynamic/plane.yaml

http:
  routers:
    plane-space:
      rule: Host(`plane.example.com`) && PathPrefix(`/spaces/`)
      entrypoints:
        - websecure
      service: plane-space
      tls:
        certresolver: http_resolver

    plane-admin:
      rule: Host(`plane.example.com`) && PathPrefix(`/god-mode/`)
      entrypoints:
        - websecure
      service: plane-admin
      tls:
        certresolver: http_resolver

    plane-backend:
      rule: Host(`plane.example.com`) && PathPrefix(`/api/`)
      entrypoints:
        - websecure
      service: plane-backend
      tls:
        certresolver: http_resolver

    plane-auth:
      rule: Host(`plane.example.com`) && PathPrefix(`/auth/`)
      entrypoints:
        - websecure
      service: plane-auth
      tls:
        certresolver: http_resolver

    plane-uploads:
      rule: Host(`plane.example.com`) && PathPrefix(`/plane/`)
      entrypoints:
        - websecure
      service: plane-uploads
      tls:
        certresolver: http_resolver

    plane-frontend:
      rule: Host(`plane.example.com`)
      entrypoints:
        - websecure
      service: plane-frontend
      tls:
        certresolver: http_resolver

  services:
    plane-frontend:
      loadbalancer:
        servers:
          - url: http://plane-frontend:3000

    plane-backend:
      loadbalancer:
        servers:
          - url: http://plane-backend:8000

    plane-auth:
      loadbalancer:
        servers:
          - url: http://plane-backend:8000

    plane-space:
      loadbalancer:
        servers:
          - url: http://plane-space:3000

    plane-admin:
      loadbalancer:
        servers:
          - url: http://plane-admin:3000

    plane-uploads:
      loadbalancer:
        servers:
          - url: http://minio:9000

[rbouma]

@vansergen ,

Thank you for the example; it did work for us. However, after the latest update from yesterday (v0.20), something has changed. Here is the updated configuration for the external domain (https://plane.example.com).

The only thing I did not get to work is the /god-mode/ on the new admin container. < fixed and updated in below code example

• compose.yaml

services:
  traefik:
    image: traefik:v3.0
    restart: unless-stopped
    container_name: traefik
    ports:
      - 80:80
      - 443:443
    volumes:
      - letsencrypt:/letsencrypt
      - ./traefik/:/etc/traefik/
    networks:
      - web

  plane-frontend:
    image: makeplane/plane-frontend:stable
    container_name: plane-frontend
    platform: linux/amd64
    pull_policy: always
    restart: unless-stopped
    env_file:
      - plane.env
    command: node web/server.js web
    depends_on:
      - plane-backend
      - plane-worker
    networks:
      - web

  plane-space:
    image: makeplane/plane-space:stable
    container_name: plane-space
    platform: linux/amd64
    pull_policy: always
    restart: unless-stopped
    env_file:
      - plane.env
    command: node space/server.js space
    depends_on:
      - plane-backend
      - plane-worker
      - plane-frontend
    networks:
      - web
      - local

  plane-admin:
    image: makeplane/plane-admin:stable
    container_name: plane-admin
    platform: linux/amd64
    pull_policy: always
    restart: unless-stopped
    env_file:
      - plane.env
    command: node admin/server.js admin
    depends_on:
      - plane-backend
      - plane-frontend
    networks:
      - web

  plane-backend:
    image: makeplane/plane-backend:stable
    container_name: plane-backend
    platform: linux/amd64
    pull_policy: always
    restart: unless-stopped
    env_file:
      - plane.env
    command: ./bin/docker-entrypoint-api.sh
    volumes:
      - logs_api:/code/plane/logs
    depends_on:
      - postgresql
      - redis
    networks:
      - web
      - local

  plane-worker:
    image: makeplane/plane-backend:stable
    container_name: plane-worker
    platform: linux/amd64
    pull_policy: always
    restart: unless-stopped
    env_file:
      - plane.env
    command: ./bin/docker-entrypoint-worker.sh
    depends_on:
      - plane-backend
      - postgresql
      - redis
    networks:
      - local

  plane-beat-worker:
    image: makeplane/plane-backend:stable
    container_name: plane-beat-worker
    platform: linux/amd64
    pull_policy: always
    restart: unless-stopped
    env_file:
      - plane.env
    command: ./bin/docker-entrypoint-beat.sh
    volumes:
      - logs_beat-worker:/code/plane/logs
    depends_on:
      - plane-backend
      - postgresql
      - redis
    networks:
      - local

  plane-migrator:
    image: makeplane/plane-backend:stable
    platform: linux/amd64
    container_name: plane-migrator
    pull_policy: always
    restart: no
    env_file:
      - plane.env
    command: ./bin/docker-entrypoint-migrator.sh
    volumes:
      - logs_migrator:/code/plane/logs
    depends_on:
      - postgresql
      - redis
    networks:
      - local

  postgresql:
    image: postgres:16-alpine
    restart: unless-stopped
    container_name: postgresql
    command: postgres -c 'max_connections=1000'
    env_file:
      - plane.env
    volumes:
      - postgresql:/var/lib/postgresql/data
    networks:
      - local

  redis:
    image: redis:7-alpine
    restart: unless-stopped
    container_name: redis
    volumes:
      - redis:/data
    networks:
      - local

  minio:
    image: quay.io/minio/minio
    restart: unless-stopped
    command: server /data --console-address ":9090"
    env_file:
      - plane.env
    container_name: minio
    volumes:
      - minio:/data
    networks:
      - web
      - local

networks:
  web:
  local:

volumes:
  letsencrypt:
  postgresql:
  redis:
  minio:
  logs_api:
  logs_worker:
  logs_beat-worker:
  logs_migrator:

• plane.env

# APP_RELEASE=latest
# WEB_REPLICAS=1
# SPACE_REPLICAS=1
# API_REPLICAS=1
WEB_URL=https://plane.example.com
DEBUG=1
NEXT_PUBLIC_DEPLOY_URL=https://plane.example.com/spaces
#SENTRY_DSN=
#SENTRY_ENVIRONMENT=production
#GOOGLE_CLIENT_ID=
#GITHUB_CLIENT_ID=
GITHUB_CLIENT_SECRET=
DOCKERIZED=1 # deprecated
CORS_ALLOWED_ORIGINS=https://plane.example.com

#DB SETTINGS
PGHOST=postgresql
PGDATABASE=plane
POSTGRES_USER=<USERNAME>
POSTGRES_PASSWORD=<PASSWORD>
POSTGRES_DB=plane
DATABASE_URL=postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${PGHOST}/${PGDATABASE}

# REDIS SETTINGS
REDIS_HOST=redis
REDIS_PORT=6379
REDIS_URL=redis://${REDIS_HOST}:${REDIS_PORT}/

# EMAIL SETTINGS
EMAIL_HOST=smtp.gmail.com
EMAIL_HOST_USER=<EMAIL>
EMAIL_HOST_PASSWORD=<PASSWORD>
EMAIL_PORT=587
EMAIL_FROM=no-reply
EMAIL_USE_TLS=1
EMAIL_USE_SSL=0

# LOGIN/SIGNUP SETTINGS
ENABLE_SIGNUP=1
ENABLE_EMAIL_PASSWORD=1
ENABLE_MAGIC_LINK_LOGIN=0
SECRET_KEY=<SUPER_SECRET_KEY>

# DATA STORE SETTINGS
USE_MINIO=1
AWS_REGION=
#AWS_ACCESS_KEY_ID=<MINIO_USER>
#AWS_SECRET_ACCESS_KEY=<MINIO_PASSWORD>
AWS_S3_ENDPOINT_URL=http://minio:9000
AWS_S3_BUCKET_NAME=plane
MINIO_ROOT_USER=<MINIO_USER>
MINIO_ROOT_PASSWORD=<MINIO_PASSWORD>
BUCKET_NAME=plane
FILE_SIZE_LIMIT=5242880

# Gunicorn Workers
GUNICORN_WORKERS=2

• traefik/traefik.yaml

entryPoints:
  web:
    address: :80
    http:
      redirections:
        entryPoint:
          to: websecure
          scheme: https
  websecure:
    address: :443

certificatesresolvers:
  http_resolver:
    acme:
      httpchallenge:
        entrypoint: web
      email: <YOUR_EMAIL>
      storage: /letsencrypt/acme.json

providers:
  file:
    directory: /etc/traefik/dynamic
    watch: true

• traefik/dynamic/plane.yaml

http:
  routers:
    plane-space:
      rule: Host(`plane.example.com`) && PathPrefix(`/spaces/`)
      entrypoints:
        - websecure
      service: plane-space
      tls:
        certresolver: http_resolver

    plane-backend:
      rule: Host(`plane.example.com`) && PathPrefix(`/api/`)
      entrypoints:
        - websecure
      service: plane-backend
      tls:
        certresolver: http_resolver

    plane-admin:
      rule: Host(`plane.example.com`) && PathPrefix(`/god-mode/`)
      entrypoints:
        - websecure
      service: plane-admin
      tls:
        certresolver: http_resolver

    plane-auth:
      rule: Host(`plane.example.com`) && PathPrefix(`/auth/`)
      entrypoints:
        - websecure
      service: plane-auth
      tls:
        certresolver: http_resolver

    plane-uploads:
      rule: Host(`plane.example.com`) && PathPrefix(`/plane/`)
      entrypoints:
        - websecure
      service: plane-uploads
      tls:
        certresolver: http_resolver

    plane-frontend:
      rule: Host(`plane.example.com`)
      entrypoints:
        - websecure
      service: plane-frontend
      tls:
        certresolver: http_resolver

  services:
    plane-frontend:
      loadbalancer:
        servers:
          - url: http://plane-frontend:3000

    plane-admin:
      loadbalancer:
        servers:
          - url: http://plane-admin:3000

    plane-backend:
      loadbalancer:
        servers:
          - url: http://plane-backend:8000

    plane-auth:
      loadbalancer:
        servers:
          - url: http://plane-backend:8000

    plane-space:
      loadbalancer:
        servers:
          - url: http://plane-space:3000

    plane-uploads:
      loadbalancer:
        servers:
          - url: http://minio:9000/

[rbouma]

@vansergen I did not have a deep look in this issue but, when i go to plane.example.com/god-mode I got Workspace not found error and when I goto to plane.example.com/god-mode/ <- (with forward ending slash) I got "Bad Gateway" message.

I don't have the ADMIN_BASE_URL configured as its defaulted to BASE_URL + '/god-mode/'

[vansergen]

@rbouma I updated my answer to match the latest version. Please let me if it works for you. But it seems that my config is almost identical to yours

[rbouma]

@vansergen Thanks for providing your example. My issue was that I had connected both the web and local networks to the plane-admin container. Removing the local network fixed the problem. I also updated my code.

[rbouma]

@vansergen do you get the api working? On every api endpoint I got "Page not found." response:

[vansergen]

@rbouma Yes, I provided a working config. Did it work for you? (config I posted from the above answer)

[Matheus-h-Campos]

I can't seem to get the API to work correctly. Here's a breakdown of my stack configuration and environment details.

I'm using docker swarm.

version: "3.8"

services:

  plane-frontend:
    image: makeplane/plane-frontend:v0.22-dev
    command: node web/server.js web
    env_file:
      - plane.env
    networks:
      - network_public
    deploy:
      mode: replicated
      replicas: 1
      placement:
        constraints:
          - node.role == manager
      update_config:
        parallelism: 1
        order: stop-first
      resources:
        limits:
          cpus: '0.5'
          memory: 512M
        reservations:
          cpus: '0.25'
          memory: 256M
      labels:
        - traefik.enable=true
        - traefik.http.routers.plane-frontend.rule=Host(`plane.example.com`)
        - traefik.http.routers.plane-frontend.entrypoints=websecure
        - traefik.http.routers.plane-frontend.tls.certresolver=letsencryptresolver
        - traefik.http.services.plane-frontend.loadbalancer.server.port=3000
      

  plane-space:
    image: makeplane/plane-space:v0.22-dev
    
    command: node space/server.js space
    env_file:
      - plane.env
    networks:
      - network_public
    deploy:
      mode: replicated
      replicas: 1
      placement:
        constraints:
          - node.role == manager
      update_config:
        parallelism: 1
        order: stop-first
      resources:
        limits:
          cpus: '0.5'
          memory: 512M
        reservations:
          cpus: '0.25'
          memory: 256M
      labels:
        - traefik.enable=true
        - traefik.http.routers.plane-space.rule=Host(`plane.example.com`) && PathPrefix(`/spaces/`)
        - traefik.http.routers.plane-space.entrypoints=websecure
        - traefik.http.routers.plane-space.tls.certresolver=letsencryptresolver
        - traefik.http.services.plane-space.loadbalancer.server.port=3000

  plane-admin:
    image: makeplane/plane-admin:v0.22-dev
    
    command: node admin/server.js admin
    env_file:
      - plane.env
    networks:
      - network_public
    deploy:
      mode: replicated
      replicas: 1
      placement:
        constraints:
          - node.role == manager
      update_config:
        parallelism: 1
        order: stop-first
      resources:
        limits:
          cpus: '0.5'
          memory: 512M
        reservations:
          cpus: '0.25'
          memory: 256M
      labels:
        - traefik.enable=true
        - traefik.http.routers.plane-admin.rule=Host(`plane.example.com`) && PathPrefix(`/god-mode/`)
        - traefik.http.routers.plane-admin.entrypoints=websecure
        - traefik.http.routers.plane-admin.tls.certresolver=letsencryptresolver
        - traefik.http.services.plane-admin.loadbalancer.server.port=3000

  plane-backend:
    image: makeplane/plane-backend:v0.22-dev
    
    command: ./bin/docker-entrypoint-api.sh
    env_file:
      - plane.env
    volumes:
      - logs_api:/code/plane/logs
    networks:
      - network_public
    deploy:
      mode: replicated
      replicas: 1
      placement:
        constraints:
          - node.role == manager
      update_config:
        parallelism: 1
        order: stop-first
      resources:
        limits:
          cpus: '1'
          memory: 1G
        reservations:
          cpus: '0.5'
          memory: 512M
      labels:
        - traefik.enable=true
        - traefik.http.routers.plane-backend.rule=Host(`plane.example.com`) && (PathPrefix(`/api/`) || PathPrefix(`/auth/`))
        - traefik.http.routers.plane-backend.entrypoints=websecure
        - traefik.http.routers.plane-backend.tls.certresolver=letsencryptresolver
        - traefik.http.services.plane-backend.loadbalancer.server.port=8000
        ### This didn't work ###
        #- traefik.http.routers.plane-auth.rule=Host(`plane.example.com`) && PathPrefix(`/api/`)
        #- traefik.http.routers.plane-auth.entrypoints=websecure
        #- traefik.http.routers.plane-auth.tls.certresolver=letsencryptresolver
        #- traefik.http.services.plane-auth.loadbalancer.server.port=8000

  plane-worker:
    image: makeplane/plane-backend:v0.22-dev
    
    command: ./bin/docker-entrypoint-worker.sh
    env_file:
      - plane.env
    volumes:
      - logs_worker:/code/plane/logs
    networks:
      - network_public
    deploy:
      mode: replicated
      replicas: 1
      placement:
        constraints:
          - node.role == manager
      update_config:
        parallelism: 1
        order: stop-first
      resources:
        limits:
          cpus: '0.5'
          memory: 1024M
        reservations:
          cpus: '0.25'
          memory: 256M

  plane-beat-worker:
    image: makeplane/plane-backend:v0.22-dev
    
    command: ./bin/docker-entrypoint-beat.sh
    env_file:
      - plane.env
    volumes:
      - logs_beat-worker:/code/plane/logs
    networks:
      - network_public
    deploy:
      mode: replicated
      replicas: 1
      placement:
        constraints:
          - node.role == manager
      update_config:
        parallelism: 1
        order: stop-first
      resources:
        limits:
          cpus: '0.5'
          memory: 512M
        reservations:
          cpus: '0.25'
          memory: 256M

  plane-migrator:
    image: makeplane/plane-backend:v0.22-dev
    
    command: ./bin/docker-entrypoint-migrator.sh
    env_file:
      - plane.env
    volumes:
      - logs_migrator:/code/plane/logs
    networks:
      - network_public
    deploy:
      mode: replicated
      replicas: 1
      placement:
        constraints:
          - node.role == manager
      restart_policy:
        condition: on-failure
      resources:
        limits:
          cpus: '0.5'
          memory: 512M
        reservations:
          cpus: '0.25'
          memory: 256M

networks:
  network_public:
    external: true
    name: network_public

volumes:
  logs_api:
    external: true
    name: logs_api
  logs_worker:
    external: true
    name: logs_worker
  logs_beat-worker:
    external: true
    name: logs_beat-worker
  logs_migrator:
    external: true
    name: logs_migrator

.env File

# Gunicorn Workers
GUNICORN_WORKERS=2

# DOCKERIZED=1

# Secret Key
SECRET_KEY=Delouse_Frolic_Arrogant

DEBUG=1
# APP_RELEASE=v0.22-dev
# WEB_REPLICAS=1
# SPACE_REPLICAS=1
# API_REPLICAS=1

# CORS
CORS_ALLOWED_ORIGINS=https://plane.example.com

# Database
DATABASE_URL=postgresql://postgres:PASSWORD@pgbouncer/plane

# REDIS SETTINGS
REDIS_URL=redis://redis:6379/

# AWS S3
# AWS_REGION=
AWS_ACCESS_KEY_ID=<Minio User>
AWS_SECRET_ACCESS_KEY=<Minio Password>
AWS_S3_ENDPOINT_URL=http://minio:9000
AWS_S3_BUCKET_NAME=plane
# MINIO_ROOT_USER=
# MINIO_ROOT_PASSWORD=
BUCKET_NAME=plane
FILE_SIZE_LIMIT=5242880

# URLs
# SPACE_BASE_URL=https://plane.example.com/spaces/
# ADMIN_BASE_URL=https://plane.example.com/god-mode/
# NEXT_PUBLIC_DEPLOY_URL=https://plane.example.com/spaces/
WEB_URL=https://plane.example.com

# EMAIL SETTINGS
EMAIL_HOST=
EMAIL_HOST_USER=
EMAIL_HOST_PASSWORD=
EMAIL_PORT=
EMAIL_FROM=no-reply
EMAIL_USE_TLS=1
EMAIL_USE_SSL=0

# LOGIN/SIGNUP SETTINGS
ENABLE_SIGNUP=1
ENABLE_EMAIL_PASSWORD=1
ENABLE_MAGIC_LINK_LOGIN=0

[abetoots]

did you ever get this to work? @Matheus-h-Campos

[Aeyos278]

I finally managed to set up everything with Traefik thanks to this post (in its latest version). Thank you very much (3 days of hassle before understanding that you also need to redirect /god-mode/ ... :p)