Enabling under Traefik example? #3432

davekeeshan · 2024-01-22T23:53:14Z

davekeeshan
Jan 22, 2024

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 · 2024-01-30T00:15:54Z

davekeeshan
Jan 30, 2024
Author

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.

1 reply

mguptahub Feb 1, 2024
Maintainer

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 · 2024-02-01T16:58:45Z

davekeeshan
Feb 1, 2024
Author

@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:

1 reply

davekeeshan Feb 6, 2024
Author

@mguptahub bump!

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

vansergen · 2024-03-21T09:39:46Z

vansergen
Mar 21, 2024

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

0 replies

rbouma · 2024-05-24T14:40:58Z

rbouma
May 24, 2024

@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/

7 replies

rbouma May 25, 2024

@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 May 25, 2024

@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 May 25, 2024

@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 Jun 5, 2024

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

vansergen Jun 14, 2024

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

Matheus-h-Campos · 2024-09-23T17:04:22Z

Matheus-h-Campos
Sep 23, 2024

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

2 replies

abetoots Feb 9, 2025

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

rbouma Apr 28, 2025

Hey @Matheus-h-Campos,

I took a look at your setup, and I think I see why the API isn’t working correctly.

You're currently combining both /api/ and /auth/ paths into a single Traefik router using this rule:

- traefik.http.routers.plane-backend.rule=Host(`plane.example.com`) && (PathPrefix(`/api/`) || PathPrefix(`/auth/`))

While this can work in some cases, Traefik (especially in Docker Swarm) tends to be more reliable when you define separate routers for each path. I noticed you tried that but mentioned it didn’t work — I believe it just needs a small adjustment.

Here’s what I suggest for your plane-backend service labels:

labels:
  - traefik.enable=true

  # API Router
  - traefik.http.routers.plane-backend.rule=Host(`plane.example.com`) && PathPrefix(`/api/`)
  - traefik.http.routers.plane-backend.entrypoints=websecure
  - traefik.http.routers.plane-backend.tls.certresolver=letsencryptresolver
  - traefik.http.services.plane-backend.loadbalancer.server.port=8000

  # AUTH Router
  - traefik.http.routers.plane-auth.rule=Host(`plane.example.com`) && PathPrefix(`/auth/`)
  - traefik.http.routers.plane-auth.entrypoints=websecure
  - traefik.http.routers.plane-auth.tls.certresolver=letsencryptresolver
  - traefik.http.services.plane-auth.loadbalancer.server.port=8000

Both routes will point to the same backend service on port 8000, but Traefik will handle them more cleanly this way.

A few extra tips:

Double-check your CORS_ALLOWED_ORIGINS — looks fine, but always good to be sure.
Watch out for trailing slashes (/api vs /api/). Traefik is generally okay, but some backend apps can be sensitive to this.
After applying changes, don’t forget to redeploy your stack and clear any cached configs Traefik might have.

Let me know if this helps — I think this should resolve the "Page not found" issue on your API endpoints!

Good luck, and feel free to ping if you run into anything else!

Aeyos278 · 2025-04-26T15:28:21Z

Aeyos278
Apr 26, 2025

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)

2 replies

Matheus-h-Campos Apr 28, 2025

Awesome!

Also, do you mind sharing the stack mby any chance?

Aeyos278 Apr 29, 2025

What saved me was discovering that you need to configure a certain management of /god-mode/ etc. in Traefik. This is missing from the official documentation. Currently, even if the product works, I encounter difficulties uploading files; something is still missing. Plane doesn't connect properly to MinIO. Once it's fixed, I will share my configuration with you.

Aeyos278 · 2025-05-01T17:51:57Z

Aeyos278
May 1, 2025

I managed to get the minio working; a road was missing. Here is my documentation that covers all of that; if it helps someone, I would be happy. In French because I am French and I fear messing it up by using a translator.

Documentation personnelle de configuration pour Plane (édition communautaire, self-hosted)

Objectif

Cette documentation explique comment adapter une installation Plane communautaire (v0.25.3) avec Traefik en tant que proxy inverse, en se basant sur la configuration Nginx fournie dans le conteneur d'origine (conteneur docker makeplane/plane-proxy exclus donc de mon fichier de conf).

Postulat de travail

J’ai souhaité pouvoir accéder directement à l’interface web de Traefik, de Minio et de RabbitMQ. J’ai donc choisi de créer des routes permettant cela vers des sous-domaines dédiés (utilisation de sous-domaines nécessaire afin de solutionner les soucis de CORS).

1. Analyse des redirections Nginx d'origine

Après analyse du fichier de configuration Nginx inclus dans l'image Docker officielle de Plane proxy (/etc/nginx/nginx.conf), voici les redirections implémentées :

Chemin public	Redirection vers le service interne
`/`	http://web:3000/
`/api/`	http://api:8000/api/
`/auth/`	http://api:8000/auth/
`/god-mode/`	http://admin:3000/god-mode/
`/live/`	http://live:3000/live/
`/spaces/`	http://space:3000/spaces/
`/uploads`	http://plane-minio:9000/uploads

Ces routes ont été reproduites dans la configuration Traefik via des labels Docker, comme illustré dans le fichier docker-compose.yaml joint.

Remarque importante :
La route /m/ n’est pas supportée dans l'édition communautaire de Plane. Elle est réservée à l'édition commerciale.
L'application mobile tente d'accéder à /m/auth, ce qui produit une erreur 404 dans l’édition communautaire.

2. Variables d'environnement essentielles

Pour garantir le bon fonctionnement de Plane, sécurisé, en autorisant la définition de mot de passe personnel pour les services de base de données, j'ai été obligé de définir certaines variables d'environnement.

Sans ces dernières, il n'est pas possible de personnaliser les identifiants et mots de passe. Même si PostgreSQL récupère bien notre personnalisation via les variables existantes dans le fichier plane.env, le reste des conteneurs ne les récupère pas et ne les utilise pas.

En ajoutant les variables débutant par PLANE_, le problème est résolu.
Ces variables doivent être créées dans le fichier plane.env ainsi que déclarées en début du fichier docker-compose.yaml.

Voici en exemple mon fichier plane.env anonymisé :

plane.env.txt

Ce fichier doit être placé à la racine de votre dossier plane-app.

3. Fichier de configuration Docker : `docker-compose.yaml`

docker-compose.yml.txt

0 replies

Enabling under Traefik example? #3432

Uh oh!

Replies: 7 comments · 13 replies

Uh oh!

Uh oh!

davekeeshan Jan 30, 2024 Author

Uh oh!

mguptahub Feb 1, 2024 Maintainer

Uh oh!

davekeeshan Feb 1, 2024 Author

Uh oh!

davekeeshan Feb 6, 2024 Author

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

A few extra tips:

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Documentation personnelle de configuration pour Plane (édition communautaire, self-hosted)

Objectif

Postulat de travail

1. Analyse des redirections Nginx d'origine

2. Variables d'environnement essentielles

3. Fichier de configuration Docker : docker-compose.yaml

Replies: 7 comments 13 replies

davekeeshan
Jan 30, 2024
Author

mguptahub Feb 1, 2024
Maintainer

davekeeshan
Feb 1, 2024
Author

davekeeshan Feb 6, 2024
Author

3. Fichier de configuration Docker : `docker-compose.yaml`