docker-compose.yml - master - evcode/n8n-setup

docker-compose.yml
398 строк13 KB
Evgeny Epifanov
Directus s3
16 фев 2026, 10:43
16 фев 2026, 10:43b630470
services:

    traefik:
        image: traefik:v3.6
        ports:
            - "80:80"
            - "8080:8080"
            - "443:443"
        volumes:
            - /var/run/docker.sock:/var/run/docker.sock
            - ./traefik/traefik.yml:/etc/traefik/traefik.yml:ro
            - ./traefik/certs:/var/traefik/certs/:rw
        networks:
            - proxy
        restart: unless-stopped
        command:
            - '--certificatesresolvers.letsencrypt.acme.email=${TRAEFIK_ACME_EMAIL}'
            - '--ping'
        healthcheck:
            test: traefik healthcheck --ping
            interval: 30s
            timeout: 10s
            retries: 3
            start_period: 30s
        logging:
            driver: "json-file"
            options:
                max-size: "10m"
                max-file: "3"

    n8n:
        container_name: n8n
        image: docker.n8n.io/n8nio/n8n
        user: "${PUID}:${PGID}"
        # ports:
        #     - 5678:5678
        environment:
            NODE_ENV: production
            N8N_SECURE_COOKIE: ${N8N_SECURE_COOKIE}
            N8N_HOST: ${N8N_HOST}
            N8N_PROTOCOL: https
            N8N_WEBHOOK_URL: ${N8N_WEBHOOK_URL}
            WEBHOOK_URL: ${N8N_WEBHOOK_URL}
            N8N_ENCRYPTION_KEY: ${N8N_ENCRYPTION_KEY}
            N8N_EDITOR_BASE_URL: ${N8N_EDITOR_BASE_URL}
            N8N_PROXY_HOPS: 1
            GENERIC_TIMEZONE: ${TIMEZONE}
            TZ: ${TIMEZONE}

            N8N_COMMUNITY_PACKAGES_ENABLED: ${N8N_COMMUNITY_PACKAGES_ENABLED:-true}
            N8N_VERSION_NOTIFICATIONS_ENABLED: ${N8N_VERSION_NOTIFICATIONS_ENABLED:-true}
            N8N_TEMPLATES_ENABLED: ${N8N_TEMPLATES_ENABLED:-true}
            N8N_PUBLIC_API_DISABLED: ${N8N_PUBLIC_API_DISABLED:-false}
            N8N_DIAGNOSTICS_ENABLED: ${N8N_DIAGNOSTICS_ENABLED:-true}
            N8N_RESTRICT_FILE_ACCESS_TO: '/home/node/files'

            N8N_RUNNERS_MODE: external
            N8N_RUNNERS_BROKER_LISTEN_ADDRESS: 0.0.0.0
            N8N_RUNNERS_BROKER_PORT: 5679
            N8N_NATIVE_PYTHON_RUNNER: true
            N8N_RUNNERS_AUTH_TOKEN: ${N8N_RUNNERS_AUTH_TOKEN}

            DB_TYPE: postgresdb
            DB_POSTGRESDB_DATABASE: ${N8N_DB_NAME}
            DB_POSTGRESDB_HOST: ${DB_HOST}
            DB_POSTGRESDB_PORT: ${DB_PORT}
            DB_POSTGRESDB_USER: ${N8N_DB_USER}
            DB_POSTGRESDB_PASSWORD: ${N8N_DB_PASSWORD}
        volumes:
            - "./n8n/data:/home/node/.n8n"
            - "./n8n/files:/home/node/files"
        restart: unless-stopped
        healthcheck:
            test: wget --spider http://localhost:5678/healthz > /dev/null 2>&1 || exit 1
            interval: 30s
            timeout: 10s
            retries: 3
            start_period: 30s
        depends_on:
            postgres:
                condition: service_healthy
            redis:
                condition: service_healthy
            qdrant:
                condition: service_healthy
        networks:
            - proxy
        labels:
            - "traefik.enable=true"
            - "traefik.http.routers.n8n.rule=Host(`${N8N_HOST}`)"
            - "traefik.http.routers.n8n.entrypoints=web,websecure"
            - "traefik.http.routers.n8n.tls=true"
            - "traefik.http.routers.n8n.tls.certresolver=letsencrypt"
            - "traefik.http.services.n8n.loadbalancer.server.port=5678"
        logging:
            driver: "json-file"
            options:
                max-size: "10m"
                max-file: "3"

    task-runners:
        image: n8nio/runners:latest
        container_name: n8n-runners
        restart: unless-stopped
        networks:
            - proxy
        environment:
            N8N_RUNNERS_PYTHON_ENABLE: true
            N8N_RUNNERS_TASK_BROKER_URI: http://n8n:5679
            N8N_RUNNERS_AUTH_TOKEN: ${N8N_RUNNERS_AUTH_TOKEN}
            GENERIC_TIMEZONE: ${TIMEZONE}
            TZ: ${TIMEZONE}
        depends_on:
            - n8n
        logging:
            driver: "json-file"
            options:
                max-size: "10m"
                max-file: "3"

    redis:
        image: redis:latest
        restart: unless-stopped
        networks:
            - proxy
        healthcheck:
            test: ["CMD-SHELL", "[ $$(redis-cli ping) = 'PONG' ]"]
            interval: 30s
            timeout: 10s
            retries: 3
            start_period: 30s
        logging:
            driver: "json-file"
            options:
                max-size: "10m"
                max-file: "3"

    qdrant:
        image: qdrant/qdrant:latest
        restart: unless-stopped
        container_name: qdrant
        environment:
            QDRANT__SERVICE__API_KEY: ${QDRANT_SECRET}
        # ports:
        #     - 6333:6333
        #     - 6334:6334
        expose:
            - 6333
            - 6334
            - 6335
        volumes:
            - ./qdrant/data:/qdrant/storage
            - ./qdrant/config.yaml:/qdrant/config/config.yaml:ro
        networks:
            - proxy
        labels:
            - "traefik.enable=true"
            - "traefik.http.routers.qdrant.rule=Host(`${QDRANT_HOST}`)"
            - "traefik.http.routers.qdrant.entrypoints=web,websecure"
            - "traefik.http.routers.qdrant.tls=true"
            - "traefik.http.routers.qdrant.tls.certresolver=letsencrypt"
            - "traefik.http.services.qdrant.loadbalancer.server.port=6333"
        healthcheck:
            test:
                - CMD-SHELL
                - bash -c ':> /dev/tcp/127.0.0.1/6333' || exit 1
            interval: 30s
            timeout: 10s
            retries: 3
            start_period: 30s
        logging:
            driver: "json-file"
            options:
                max-size: "10m"
                max-file: "3"

    postgres:
        image: postgis/postgis:17-master
        volumes:
            - ./postgres/data:/var/lib/postgresql/data
            - ./postgres/init:/docker-entrypoint-initdb.d
        networks:
            - proxy
        environment:
            POSTGRES_USER: ${DB_USER}
            POSTGRES_PASSWORD: ${DB_PASSWORD}
            POSTGRES_DB: ${DB_NAME}

            N8N_DB_NAME: ${N8N_DB_NAME}
            N8N_DB_USER: ${N8N_DB_USER}
            N8N_DB_PASSWORD: ${N8N_DB_PASSWORD}

            CUSTOM_DB_NAME: ${CUSTOM_DB_NAME}
            CUSTOM_DB_USER: ${CUSTOM_DB_USER}
            CUSTOM_DB_PASSWORD: ${CUSTOM_DB_PASSWORD}

            NOCODB_DB_NAME: ${NOCODB_DB_NAME}
            NOCODB_DB_USER: ${NOCODB_DB_USER}
            NOCODB_DB_PASSWORD: ${NOCODB_DB_PASSWORD}

            DIRECTUS_DB_NAME: ${DIRECTUS_DB_NAME}
            DIRECTUS_DB_USER: ${DIRECTUS_DB_USER}
            DIRECTUS_DB_PASSWORD: ${DIRECTUS_DB_PASSWORD}
        healthcheck:
            test: 'pg_isready -U "$$POSTGRES_USER" -d "$$POSTGRES_DB"'
            interval: 30s
            timeout: 10s
            retries: 3
            start_period: 30s
        logging:
            driver: "json-file"
            options:
                max-size: "10m"
                max-file: "3"
    
    pgadmin:
        image: dpage/pgadmin4
        container_name: pgadmin
        environment:
            PGADMIN_DEFAULT_EMAIL: ${PGADMIN_DEFAULT_EMAIL}
            PGADMIN_DEFAULT_PASSWORD: ${PGADMIN_DEFAULT_PASSWORD}
        # ports:
        #     - 5050:80
        volumes:
            - ./pgadmin:/var/lib/pgadmin
        depends_on:
            postgres:
                condition: service_healthy
        restart: unless-stopped
        networks:
            - proxy
        labels:
            - "traefik.enable=true"
            - "traefik.http.routers.pgadmin.rule=Host(`${PGADMIN_HOST}`)"
            - "traefik.http.routers.pgadmin.entrypoints=web,websecure"
            - "traefik.http.routers.pgadmin.tls=true"
            - "traefik.http.routers.pgadmin.tls.certresolver=letsencrypt"
            - "traefik.http.services.pgadmin.loadbalancer.server.port=80"
        healthcheck:
            test: ["CMD", "wget", "-O", "-", "http://localhost:80/misc/ping"]
            interval: 30s
            timeout: 10s
            retries: 3
            start_period: 30s
        logging:
            driver: "json-file"
            options:
                max-size: "10m"
                max-file: "3"

    nocodb:
        container_name: nocodb
        image: "nocodb/nocodb:latest"
        user: "${PUID}:${PGID}"
        environment:
            NC_DB: "pg://${DB_HOST}:${DB_PORT}?u=${NOCODB_DB_USER}&p=${NOCODB_DB_PASSWORD}&d=${NOCODB_DB_NAME}"
            NC_PUBLIC_URL: ${NOCODB_PUBLIC_URL}

            NC_ADMIN_EMAIL: ${NOCODB_ADMIN_EMAIL}
            NC_ADMIN_PASSWORD: ${NOCODB_ADMIN_PASSWORD}

            # NC_S3_BUCKET_NAME: ${NOCODB_S3_BUCKET_NAME}
            # NC_S3_REGION: ${NOCODB_S3_REGION}
            # NC_S3_ENDPOINT: ${NOCODB_S3_ENDPOINT}
            # NC_S3_ACCESS_KEY: ${NOCODB_S3_ACCESS_KEY}
            # NC_S3_ACCESS_SECRET: ${NOCODB_S3_ACCESS_SECRET}
            # NC_S3_FORCE_PATH_STYLE: ${NOCODB_S3_FORCE_PATH_STYLE}
        # ports:
        #     - 8080:8080
        depends_on:
            postgres:
                condition: service_healthy
        restart: unless-stopped
        volumes:
            - "./nocodb/data:/usr/app/data"
        networks:
            - proxy
        labels:
            - "traefik.enable=true"
            - "traefik.http.routers.nocodb.rule=Host(`${NOCODB_HOST}`)"
            - "traefik.http.routers.nocodb.entrypoints=web,websecure"
            - "traefik.http.routers.nocodb.tls=true"
            - "traefik.http.routers.nocodb.tls.certresolver=letsencrypt"
            - "traefik.http.services.nocodb.loadbalancer.server.port=8080"
        healthcheck:
            test: ["CMD", "curl", "--fail", "http://localhost:8080/api/v1/health"]
            interval: 30s
            timeout: 10s
            retries: 3
            start_period: 30s
        logging:
            driver: "json-file"
            options:
                max-size: "10m"
                max-file: "3"

    directus:
        image: directus/directus:latest
        user: "${PUID}:${PGID}"
        # ports:
        #     - 8055:8055
        volumes:
            - ./directus/uploads:/directus/uploads
            - ./directus/extensions:/directus/extensions
        depends_on:
            postgres:
                condition: service_healthy
            redis:
                condition: service_healthy
        environment:
            SECRET: ${DIRECTUS_SECRET}

            DB_CLIENT: "pg"
            DB_HOST: ${DB_HOST}
            DB_PORT: ${DB_PORT}
            DB_DATABASE: ${DIRECTUS_DB_NAME}
            DB_USER: ${DIRECTUS_DB_USER}
            DB_PASSWORD: ${DIRECTUS_DB_PASSWORD}

            CACHE_ENABLED: "true"
            CACHE_AUTO_PURGE: "true"
            CACHE_STORE: "redis"
            REDIS: ${REDIS}

            ADMIN_EMAIL: ${DIRECTUS_ADMIN_EMAIL}
            ADMIN_PASSWORD: ${DIRECTUS_ADMIN_PASSWORD}
            PROJECT_OWNER: ${DIRECTUS_ADMIN_EMAIL}
            ACCEPT_TERMS: true

            PUBLIC_URL: ${DIRECTUS_PUBLIC_URL}

            # STORAGE_LOCATIONS: ${DIRECTUS_STORAGE_LOCATIONS}

            # STORAGE_S3_DRIVER: ${DIRECTUS_STORAGE_S3_DRIVER}
            # STORAGE_S3_ROOT: ${DIRECTUS_STORAGE_S3_ROOT}
            # STORAGE_S3_KEY: ${DIRECTUS_STORAGE_S3_KEY}
            # STORAGE_S3_SECRET: ${DIRECTUS_STORAGE_S3_SECRET}
            # STORAGE_S3_BUCKET: ${DIRECTUS_STORAGE_S3_BUCKET}
            # STORAGE_S3_REGION: ${DIRECTUS_STORAGE_S3_REGION}
            # STORAGE_S3_ENDPOINT: ${DIRECTUS_STORAGE_S3_ENDPOINT}
            # STORAGE_S3_FORCE_PATH_STYLE: ${DIRECTUS_STORAGE_S3_FORCE_PATH_STYLE}
        restart: unless-stopped
        networks:
            - proxy
        labels:
            - "traefik.enable=true"
            - "traefik.http.routers.directus.rule=Host(`${DIRECTUS_HOST}`)"
            - "traefik.http.routers.directus.entrypoints=web,websecure"
            - "traefik.http.routers.directus.tls=true"
            - "traefik.http.routers.directus.tls.certresolver=letsencrypt"
            - "traefik.http.services.directus.loadbalancer.server.port=8055"
        healthcheck:
            test: "wget --no-verbose --tries=1 --spider http://0.0.0.0:8055/server/health || exit 1"
            interval: 30s
            timeout: 10s
            retries: 3
            start_period: 30s
        logging:
            driver: "json-file"
            options:
                max-size: "10m"
                max-file: "3"

    restic:
        image: restic-pg:latest
        build:
            context: .
            dockerfile: backups/Dockerfile
        user: "${PUID}:${PGID}"
        hostname: restic-backup
        volumes:
            - ./backups/local:/repo
            - ./backups/tmp:/tmp/backups
            - ./backups/scripts:/scripts
            - ./n8n/files:/n8n/files:ro
            - ./n8n/data:/n8n/data:ro
            - ./nocodb/data:/nocodb/data:ro
            - ./qdrant/data:/qdrant/data:ro
            - ./directus:/directus:ro
            - ./.env:/.env.backup
        environment:
            RESTIC_REPOSITORY: /repo
            RESTIC_PASSWORD: ${RESTIC_PASSWORD}
            RESTIC_REPO_S3: ${RESTIC_REPO_S3}
            RESTIC_KEEP_LAST: ${RESTIC_KEEP_LAST:-3}
            PG_HOST: postgres
            PG_PORT: ${DB_PORT}
            PG_USER: ${DB_USER}
            PG_PASS: ${DB_PASSWORD}
            AWS_ACCESS_KEY_ID: ${AWS_ACCESS_KEY_ID}
            AWS_SECRET_ACCESS_KEY: ${AWS_SECRET_ACCESS_KEY}
            AWS_DEFAULT_REGION: ${AWS_DEFAULT_REGION}
        networks:
            - proxy

networks:
    proxy:
        external: true