[bug]: Traefik configuration returning 404 on api/instances/

[pcasad]

Is there an existing issue for this?

• I have searched the existing issues

Current behavior

This config doesn't seem to work and I don't understand why, I'm running this on Ubuntu through docker compose there are other services running (N8N, NocoDB) through Traefik and I want to use it for plane too, Here's my docker-compose:

x-db-env: &db-env
  PGHOST: ${PGHOST:-plane-db}
  PGDATABASE: ${PGDATABASE:-plane}
  POSTGRES_USER: ${POSTGRES_USER:-plane}
  POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-plane}
  POSTGRES_DB: ${POSTGRES_DB:-plane}
  POSTGRES_PORT: ${POSTGRES_PORT:-5432}
  PGDATA: ${PGDATA:-/var/lib/postgresql/data}

x-redis-env: &redis-env
  REDIS_HOST: ${REDIS_HOST:-plane-redis}
  REDIS_PORT: ${REDIS_PORT:-6379}
  REDIS_URL: ${REDIS_URL:-redis://plane-redis:6379/}

x-minio-env: &minio-env
  MINIO_ROOT_USER: ${AWS_ACCESS_KEY_ID:-access-key}
  MINIO_ROOT_PASSWORD: ${AWS_SECRET_ACCESS_KEY:-secret-key}
  
x-aws-s3-env: &aws-s3-env
  AWS_REGION: ${AWS_REGION:-}
  AWS_ACCESS_KEY_ID: ${AWS_ACCESS_KEY_ID:-access-key}
  AWS_SECRET_ACCESS_KEY: ${AWS_SECRET_ACCESS_KEY:-secret-key}
  AWS_S3_ENDPOINT_URL: ${AWS_S3_ENDPOINT_URL:-http://plane-minio:9000}
  AWS_S3_BUCKET_NAME: ${AWS_S3_BUCKET_NAME:-uploads}

x-proxy-env: &proxy-env
  NGINX_PORT: ${NGINX_PORT:-80}
  BUCKET_NAME: ${AWS_S3_BUCKET_NAME:-uploads}
  FILE_SIZE_LIMIT: ${FILE_SIZE_LIMIT:-5242880}

x-mq-env: &mq-env
  # RabbitMQ Settings
  RABBITMQ_HOST: ${RABBITMQ_HOST:-plane-mq}
  RABBITMQ_PORT: ${RABBITMQ_PORT:-5672}
  RABBITMQ_DEFAULT_USER: ${RABBITMQ_USER:-plane}
  RABBITMQ_DEFAULT_PASS: ${RABBITMQ_PASSWORD:-plane}
  RABBITMQ_DEFAULT_VHOST: ${RABBITMQ_VHOST:-plane}
  RABBITMQ_VHOST: ${RABBITMQ_VHOST:-plane}

x-live-env: &live-env
  API_BASE_URL: ${API_BASE_URL:-http://api:8000}

x-app-env: &app-env
  WEB_URL: ${WEB_URL:-http://localhost}
  DEBUG: ${DEBUG:-0}
  SENTRY_DSN: ${SENTRY_DSN}
  SENTRY_ENVIRONMENT: ${SENTRY_ENVIRONMENT:-production}
  CORS_ALLOWED_ORIGINS: ${CORS_ALLOWED_ORIGINS}
  GUNICORN_WORKERS: 1
  USE_MINIO: ${USE_MINIO:-1}
  DATABASE_URL: ${DATABASE_URL:-postgresql://plane:plane@plane-db/plane}
  SECRET_KEY: ${SECRET_KEY:-60gp0byfz2dvffa45cxl20p1scy9xbpf6d8c5y0geejgkyp1b5}
  AMQP_URL: ${AMQP_URL:-amqp://plane:plane@plane-mq:5672/plane}


services:
  web:
    image: ${DOCKERHUB_USER:-makeplane}/plane-frontend:${APP_RELEASE:-stable}
    platform: ${DOCKER_PLATFORM:-}
    pull_policy: if_not_present
    restart: unless-stopped
    command: node web/server.js web
    deploy:
      replicas: ${WEB_REPLICAS:-1}
    environment:
      NEXT_PUBLIC_API_BASE_URL: /api
    networks:
      - proxy  
    depends_on:
      - api
      - worker
    labels:
      - traefik.enable=true
      - traefik.http.routers.web.rule=Host(`${APP_DOMAIN}`)
      - traefik.http.services.web.loadbalancer.server.port=3000
      - traefik.http.routers.web.entrypoints=web
    
    

  space:
    image: ${DOCKERHUB_USER:-makeplane}/plane-space:${APP_RELEASE:-stable}
    platform: ${DOCKER_PLATFORM:-}
    pull_policy: if_not_present
    restart: unless-stopped
    command: node space/server.js space
    deploy:
      replicas: ${SPACE_REPLICAS:-1}
    networks:
      - proxy
    depends_on:
      - api
      - worker
      - web
    labels:
      - traefik.enable=true
      - traefik.http.routers.api.rule=Host(`${APP_DOMAIN}`) && (PathPrefix(`/api/`) || PathPrefix(`/auth/`))
      - traefik.http.services.space.loadbalancer.server.port=3000
      - traefik.http.routers.space.entrypoints=websecure
      - traefik.http.routers.space.tls.certresolver=http_resolver

   

  admin:
    image: ${DOCKERHUB_USER:-makeplane}/plane-admin:${APP_RELEASE:-stable}
    platform: ${DOCKER_PLATFORM:-}
    pull_policy: if_not_present
    restart: unless-stopped
    command: node admin/server.js admin
    deploy:
      replicas: ${ADMIN_REPLICAS:-1}
    networks:
      - internal
    depends_on:
      - api
      - web
    labels:
      - traefik.enable=true
      - traefik.http.routers.admin.rule=Host(`${APP_DOMAIN}`) && PathPrefix(`/god-mode/`)
      - traefik.http.services.admin.loadbalancer.server.port=3000
      - traefik.http.routers.admin.entrypoints=websecure
      - traefik.http.routers.admin.tls.certresolver=mytlschallenge
  

  live:
    image: ${DOCKERHUB_USER:-makeplane}/plane-live:${APP_RELEASE:-stable}
    platform: ${DOCKER_PLATFORM:-}
    pull_policy: if_not_present
    restart: unless-stopped
    command: node live/dist/server.js live
    environment:
      <<: [ *live-env ]
    deploy:
      replicas: ${LIVE_REPLICAS:-1}
    depends_on:
      - api
      - web
    labels:
      - traefik.enable=true
      - traefik.http.routers.live.rule=Host(`${APP_DOMAIN}`) && PathPrefix(`/live/`)
      - traefik.http.routers.live.entrypoints=websecure
      - traefik.http.routers.live.tls.certresolver=mytlschallenge
      - traefik.http.services.live.loadbalancer.server.port=3000
    networks:
      - proxy

  api:
    image: ${DOCKERHUB_USER:-makeplane}/plane-backend:${APP_RELEASE:-stable}
    platform: ${DOCKER_PLATFORM:-}
    pull_policy: if_not_present
    restart: unless-stopped
    command: ./bin/docker-entrypoint-api.sh
    deploy:
      replicas: ${API_REPLICAS:-1}
    volumes:
      - logs_api:/code/plane/logs
    environment:
      <<: [ *app-env, *db-env, *redis-env, *minio-env, *aws-s3-env, *proxy-env ]
      CORS_ALLOWED_ORIGINS: https://${APP_DOMAIN}

     # API_BASE_URL: http://api:8000
    networks:
      - proxy
    depends_on:
      - plane-db
      - plane-redis
      - plane-mq
    labels:
      - traefik.enable=true
      - traefik.http.routers.api.rule=Host(plane.${APP_DOMAIN}) && (PathPrefix(`/api/`) || PathPrefix(`/auth/`)) 
      - traefik.http.routers.api.entrypoints=websecure
      - traefik.http.services.api.loadbalancer.server.port=8000
      - traefik.http.routers.live.tls.certresolver=mytlschallenge
  
      
  worker:
    image: ${DOCKERHUB_USER:-makeplane}/plane-backend:${APP_RELEASE:-stable}
    platform: ${DOCKER_PLATFORM:-}
    pull_policy: if_not_present
    restart: unless-stopped
    command: ./bin/docker-entrypoint-worker.sh
    volumes:
      - logs_worker:/code/plane/logs
    environment:
      <<: [ *app-env, *db-env, *redis-env, *minio-env, *aws-s3-env, *proxy-env ]
    networks:
      - proxy
    depends_on:
      - api
      - plane-db
      - plane-redis
      - plane-mq

  beat-worker:
    image: ${DOCKERHUB_USER:-makeplane}/plane-backend:${APP_RELEASE:-stable}
    platform: ${DOCKER_PLATFORM:-}
    pull_policy: if_not_present
    restart: unless-stopped
    command: ./bin/docker-entrypoint-beat.sh
    volumes:
      - logs_beat-worker:/code/plane/logs
    environment:
      <<: [ *app-env, *db-env, *redis-env, *minio-env, *aws-s3-env, *proxy-env ]
    networks:
      - proxy
    depends_on:
      - api
      - plane-db
      - plane-redis
      - plane-mq

  migrator:
    image: ${DOCKERHUB_USER:-makeplane}/plane-backend:${APP_RELEASE:-stable}
    platform: ${DOCKER_PLATFORM:-}
    pull_policy: if_not_present
    restart: "no"
    command: ./bin/docker-entrypoint-migrator.sh
    volumes:
      - logs_migrator:/code/plane/logs
    environment:
      <<: [ *app-env, *db-env, *redis-env, *minio-env, *aws-s3-env, *proxy-env ]
    networks:
      - proxy
    depends_on:
      - plane-db
      - plane-redis

  plane-db:
    image: postgres:15.7-alpine
    pull_policy: if_not_present
    restart: unless-stopped
    command: postgres -c 'max_connections=1000'
    environment:
      <<: *db-env
    networks:
      - proxy
    volumes:
      - pgdata:/var/lib/postgresql/data

  plane-redis:
    image: valkey/valkey:7.2.5-alpine
    pull_policy: if_not_present
    restart: unless-stopped
    networks:
      - proxy
    volumes:
      - redisdata:/data

  plane-mq:
    image: rabbitmq:3.13.6-management-alpine
    restart: always
    environment:
      <<: *mq-env
    networks:
      - proxy
    volumes:
      - rabbitmq_data:/var/lib/rabbitmq

  plane-minio:
    image: minio/minio:latest
    pull_policy: if_not_present
    restart: unless-stopped
    command: server /export --console-address ":9090"
    environment:
      <<: *minio-env
    networks:
      - proxy
    volumes:
      - uploads:/export
    labels:
    - traefik.enable=true
    - traefik.http.routers.minio.rule=Host(`{$APP_DOMAIN}`) && PathPrefix(`/${BUCKET_NAME}`)
    - traefik.http.services.minio.loadbalancer.server.port=9000
    - traefik.http.routers.minio.entrypoints=websecure
    - traefik.http.routers.minio.tls.certresolver=mytlschallenge


networks:
  proxy:
    external: true
     
volumes:
  pgdata:
  redisdata:
  
  uploads:
  logs_api:
  logs_worker:
  logs_beat-worker:
  logs_migrator:
  rabbitmq_data:
  traefik_data:

Steps to reproduce

Use above docker-compose.yaml with this traefik config:

traefik:
    image: "traefik"
    restart: always
    command:
      - "--log.level=DEBUG"
      - "--api=true"
      - "--api.insecure=true"
      - "--providers.docker.network=proxy"
      - "--providers.docker=true"
      - "--providers.docker.exposedbydefault=false"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.web.http.redirections.entryPoint.to=websecure"
      - "--entrypoints.web.http.redirections.entrypoint.scheme=https"
      - "--entrypoints.websecure.address=:443"
      - "--certificatesresolvers.mytlschallenge.acme.tlschallenge=true"
      - "--certificatesresolvers.mytlschallenge.acme.email=${SSL_EMAIL}"
      - "--certificatesresolvers.mytlschallenge.acme.storage=/letsencrypt/acme.json"
      - "--serversTransport.insecureSkipVerify=true"

    ports:
      - "80:80"
      - "443:443"
      - "8080:8080"
    volumes:
      - traefik_data:/letsencrypt
      - /var/run/docker.sock:/var/run/docker.sock:ro
    networks:
      - proxy

Environment

Production

Browser

Google Chrome

Variant

Self-hosted

Version

0.24.1

[pcasad]

Hey team, it is mostly solved, I still have REDIS connection issues but most of it is running (had to change the certificates resolver to a http_challenge instead of a http challenge)

Here's what my Live container is returning regarding REDIS I highly suspect a misconfig with Traefik causing this :

[10:12:12.614] WARN (1): Redis Client wasn't able to connect, continuing without Redis (you won't be able to sync data between multiple plane live servers)

err: {

  "type": "Error",

  "message": "getaddrinfo EAI_AGAIN plane-redis",

  "stack":

      Error: getaddrinfo EAI_AGAIN plane-redis

          at GetAddrInfoReqWrap.onlookup [as oncomplete] (node:dns:107:26)

  "errno": -3001,

  "code": "EAI_AGAIN",

  "syscall": "getaddrinfo",

  "hostname": "plane-redis"

}

x-app-env: &app-env
  environment:
    - NGINX_PORT=${NGINX_PORT:-80}
    - WEB_URL=${WEB_URL:-http://localhost}
    - DEBUG=${DEBUG:-0}
    - SENTRY_DSN=${SENTRY_DSN:-""}
    - SENTRY_ENVIRONMENT=${SENTRY_ENVIRONMENT:-"production"}
    - CORS_ALLOWED_ORIGINS=${CORS_ALLOWED_ORIGINS:-}
    # Gunicorn Workers
    - GUNICORN_WORKERS=${GUNICORN_WORKERS:-1}
    #DB SETTINGS
    - PGHOST=${PGHOST:-plane-db}
    - PGDATABASE=${PGDATABASE:-plane}
    - POSTGRES_USER=${POSTGRES_USER:-plane}
    - POSTGRES_PASSWORD=${POSTGRES_PASSWORD:-plane}
    - POSTGRES_DB=${POSTGRES_DB:-plane}
    - POSTGRES_PORT=${POSTGRES_PORT:-5432}
    - PGDATA=${PGDATA:-/var/lib/postgresql/data}
    - DATABASE_URL=${DATABASE_URL:-postgresql://plane:plane@plane-db/plane}
    # REDIS SETTINGS
    - REDIS_HOST=${REDIS_HOST:-plane-redis}
    - REDIS_PORT=${REDIS_PORT:-6379}
    - REDIS_URL=${REDIS_URL:-redis://plane-redis:6379/}

    # RabbitMQ Settings
    - RABBITMQ_HOST=${RABBITMQ_HOST:-plane-mq}
    - RABBITMQ_PORT=${RABBITMQ_PORT:-5672}
    - RABBITMQ_DEFAULT_USER=${RABBITMQ_USER:-plane}
    - RABBITMQ_DEFAULT_PASS=${RABBITMQ_PASSWORD:-plane}
    - RABBITMQ_DEFAULT_VHOST=${RABBITMQ_VHOST:-plane}
    - RABBITMQ_VHOST=${RABBITMQ_VHOST:-plane}
    - AMQP_URL=${AMQP_URL:-amqp://plane:plane@plane-mq:5672/plane}
    # Application secret
    - SECRET_KEY=${SECRET_KEY:-60gp0byfz2dvffa45cxl20p1scy9xbpf6d8c5y0geejgkyp1b5}
    # DATA STORE SETTINGS
    - USE_MINIO=${USE_MINIO:-1}
    - AWS_REGION=${AWS_REGION:-}
    - AWS_ACCESS_KEY_ID=${AWS_ACCESS_KEY_ID:-"access-key"}
    - AWS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY:-"secret-key"}
    - AWS_S3_ENDPOINT_URL=${AWS_S3_ENDPOINT_URL:-http://plane-minio:9000}
    - AWS_S3_BUCKET_NAME=${AWS_S3_BUCKET_NAME:-uploads}
    - MINIO_ROOT_USER=${MINIO_ROOT_USER:-"access-key"}
    - MINIO_ROOT_PASSWORD=${MINIO_ROOT_PASSWORD:-"secret-key"}
    - BUCKET_NAME=${BUCKET_NAME:-uploads}
    - FILE_SIZE_LIMIT=${FILE_SIZE_LIMIT:-5242880}
    # Live server env
    - API_BASE_URL=${API_BASE_URL:-http://api:8000}

services:
  web:
    <<: *app-env
    image: ${DOCKERHUB_USER:-makeplane}/plane-frontend:${APP_RELEASE:-stable}
    platform: ${DOCKER_PLATFORM:-}
    pull_policy: if_not_present
    restart: unless-stopped
    command: node web/server.js web
    networks:
      - proxy
    labels:
      - traefik.enable=true
      - traefik.http.routers.plane.rule=Host(`plane.company.com`)
      - traefik.http.routers.plane.entrypoints=web,websecure
      - traefik.http.routers.plane.tls.certresolver=http_challenge
      - traefik.http.services.plane.loadbalancer.server.port=3000
    deploy:
      replicas: ${WEB_REPLICAS:-1}
    depends_on:
      - api
      - worker

  space:
    <<: *app-env
    image: ${DOCKERHUB_USER:-makeplane}/plane-space:${APP_RELEASE:-stable}
    platform: ${DOCKER_PLATFORM:-}
    pull_policy: if_not_present
    restart: unless-stopped
    command: node space/server.js space
    networks:
      - proxy
    labels:
      - traefik.enable=true
      - traefik.http.routers.space.rule=Host(`plane.company.com`) && PathPrefix (`/spaces/`)
      - traefik.http.routers.space.entrypoints=web,websecure
      - traefik.http.routers.space.tls.certresolver=http_challenge
      - traefik.http.services.space.loadbalancer.server.port=3000
    deploy:
      replicas: ${SPACE_REPLICAS:-1}
    depends_on:
      - api
      - worker
      - web

  admin:
    <<: *app-env
    image: ${DOCKERHUB_USER:-makeplane}/plane-admin:${APP_RELEASE:-stable}
    platform: ${DOCKER_PLATFORM:-}
    pull_policy: if_not_present
    restart: unless-stopped
    command: node admin/server.js admin
    networks:
      - proxy
    labels:
      - traefik.enable=true
      - traefik.http.routers.admin.rule=Host(`plane.company.com`) && PathPrefix (`/god-mode/`)
      - traefik.http.routers.admin.entrypoints=web,websecure
      - traefik.http.routers.admin.tls.certresolver=http_challenge
      - traefik.http.services.admin.loadbalancer.server.port=3000
    deploy:
      replicas: ${ADMIN_REPLICAS:-1}
    depends_on:
      - api
      - web

  live:
    <<: *app-env
    image: ${DOCKERHUB_USER:-makeplane}/plane-live:${APP_RELEASE:-stable}
    platform: ${DOCKER_PLATFORM:-}
    pull_policy: if_not_present
    restart: unless-stopped
    command: node live/dist/server.js live
    networks: 
      - proxy
    labels:
      - traefik.enable=true
      - traefik.http.routers.live.rule=Host(`plane.company.com`) && PathPrefix (`/live/`)
      - traefik.http.routers.live.entrypoints=web,websecure
      - traefik.http.routers.live.tls.certresolver=http_challenge
      - traefik.http.services.live.loadbalancer.server.port=3000
    deploy:
      replicas: ${LIVE_REPLICAS:-1}
    depends_on:
      - api
      - web

  api:
    <<: *app-env
    image: ${DOCKERHUB_USER:-makeplane}/plane-backend:${APP_RELEASE:-stable}
    platform: ${DOCKER_PLATFORM:-}
    pull_policy: if_not_present
    restart: unless-stopped
    command: ./bin/docker-entrypoint-api.sh
    deploy:
      replicas: ${API_REPLICAS:-1}
    networks:
      - proxy
    labels:
      - traefik.enable=true
      - traefik.http.routers.api.rule=Host(`plane.company.com`) && (PathPrefix(`/api/`) || PathPrefix(`/auth/`)) 
      - traefik.http.routers.api.entrypoints=web,websecure
      - traefik.http.routers.api.tls.certresolver=http_challenge
      - traefik.http.services.api.loadbalancer.server.port=8000
    volumes:
      - logs_api:/code/plane/logs
    depends_on:
      - plane-db
      - plane-redis
      - plane-mq


  worker:
    <<: *app-env
    image: ${DOCKERHUB_USER:-makeplane}/plane-backend:${APP_RELEASE:-stable}
    platform: ${DOCKER_PLATFORM:-}
    pull_policy: if_not_present
    restart: unless-stopped
    command: ./bin/docker-entrypoint-worker.sh
    networks:
      - proxy
    volumes:
      - logs_worker:/code/plane/logs
    depends_on:
      - api
      - plane-db
      - plane-redis
      - plane-mq

  beat-worker:
    <<: *app-env
    image: ${DOCKERHUB_USER:-makeplane}/plane-backend:${APP_RELEASE:-stable}
    platform: ${DOCKER_PLATFORM:-}
    pull_policy: if_not_present
    restart: unless-stopped
    command: ./bin/docker-entrypoint-beat.sh
    networks:
      - proxy
    volumes:
      - logs_beat-worker:/code/plane/logs
    depends_on:
      - api
      - plane-db
      - plane-redis
      - plane-mq

  migrator:
    <<: *app-env
    image: ${DOCKERHUB_USER:-makeplane}/plane-backend:${APP_RELEASE:-stable}
    platform: ${DOCKER_PLATFORM:-}
    pull_policy: if_not_present
    restart: "no"
    command: ./bin/docker-entrypoint-migrator.sh
    networks:
      - proxy
    volumes:
      - logs_migrator:/code/plane/logs
    depends_on:
      - plane-db
      - plane-redis

  plane-db:
    <<: *app-env
    image: postgres:15.7-alpine
    pull_policy: if_not_present
    restart: unless-stopped
    command: postgres -c 'max_connections=1000'
    networks:
      - proxy
    volumes:
      - pgdata:/var/lib/postgresql/data

  plane-redis:
    <<: *app-env
    image: valkey/valkey:7.2.5-alpine
    pull_policy: if_not_present
    restart: unless-stopped
    networks:
      - proxy
    volumes:
      - redisdata:/data

  plane-mq:
    <<: *app-env
    image: rabbitmq:3.13.6-management-alpine
    restart: always
    networks:
      - proxy
    volumes:
      - rabbitmq_data:/var/lib/rabbitmq

  plane-minio:
    <<: *app-env
    image: minio/minio:latest
    pull_policy: if_not_present
    restart: unless-stopped
    command: server /export --console-address ":9090"
    networks:
      - proxy
    labels:
      - traefik.enable=true
      - traefik.http.routers.plane-minio.rule=Host(`plane.company.com`) && PathPrefix(`/uploads/`)
      - traefik.http.routers.plane-minio.entrypoints=web,websecure
      - traefik.http.routers.plane-minio.tls.certresolver=http_challenge
      - traefik.http.services.plane-minio.loadbalancer.server.port=9000
    volumes:
      - uploads:/export

  # Comment this if you already have a reverse proxy running
  #proxy:
  #  <<: *app-env
  # image: ${DOCKERHUB_USER:-makeplane}/plane-proxy:${APP_RELEASE:-stable}
  #  platform: ${DOCKER_PLATFORM:-}
  #  pull_policy: if_not_present
  #  restart: unless-stopped
  #  ports:
  #    - ${NGINX_PORT}:80
  #  depends_on:
  #    - web
  #    - api
  #    - space

networks:
  proxy:
    external: true

volumes:
  pgdata:
  redisdata:
  
  uploads:
  logs_api:
  logs_worker:
  logs_beat-worker:
  logs_migrator:
  rabbitmq_data: