Intlayer selbst hosten

Intlayer kann auf Ihrer eigenen Infrastruktur ausgeführt werden, kein Intlayer Cloud-Konto erforderlich. Drei Setups stehen zur Verfügung, die alle über dasselbe Installationsprogramm verwaltet werden (install.sh, install.ps1 unter Windows oder npx intlayer init infra):

Table of Contents

Veröffentlichte Images und Pakete

Alle drei Images werden aus derselben Datei docker/selfhost/Dockerfile erstellt und bei jeder Version veröffentlicht. Der Compose-Stack ruft außerdem die offiziellen Images mongo:8, redis:8-alpine und quay.io/minio/minio ab.

Einrichtung

Das Installationsprogramm fragt nach dem gewünschten Setup, prüft die Voraussetzungen (bietet die Installation von Docker an), schreibt die Umgebungsdatei mit bereits generierten Secrets und lädt die Images herunter. Es startet nichts von selbst: Die Docker-Modi benötigen zuerst einen Mailer, daher endet es mit der Ausgabe des auszuführenden Befehls. Eine erneute Ausführung ist sicher: Eine vorhandene Umgebungsdatei wird nie überschrieben, was es auch zum Upgrade-Pfad macht.

curl -fsSL https://intlayer.org/install.sh | sh -s -- --mode desktop

$env:INTLAYER_MODE = "desktop"; irm https://intlayer.org/install.ps1 | iex

npx intlayer init infra --mode desktop

                ┌─────────────────────────────┐
 browser ──────▶ │  app  (TanStack Start)  :3000│ ──┐
 (localhost)    └─────────────────────────────┘   │ VITE_BACKEND_URL (baked at build)
                ┌─────────────────────────────┐   │
                │  backend (Fastify/Bun)  :3100│ ◀─┘
                └──────────────┬──────────────┘
          ┌──────────┬─────────┼──────────────┐
          ▼          ▼         ▼               ▼
      mongo:27017  redis:6379  minio:9000   Chromium
      /data/mongo  /data/redis /data/minio  (in-image)
      (1-node RS)              minio:9001

curl -fsSL https://intlayer.org/install.sh | sh -s -- --mode docker

$env:INTLAYER_MODE = "docker"; irm https://intlayer.org/install.ps1 | iex

npx intlayer init infra --mode docker

# Option A: Resend
RESEND_API_KEY=<your-resend-key>

# Option B: SMTP (takes over from Resend as soon as MAIL_SMTP_HOST is set)
MAIL_SMTP_HOST=smtp.example.com
MAIL_SMTP_PORT=587
MAIL_SMTP_USER=<user>
MAIL_SMTP_PASSWORD=<password>
MAIL_FROM=Intlayer <no-reply@example.com>

docker run -d --name intlayer \
  --restart unless-stopped \
  -p 3000:3000 -p 3100:3100 -p 9000:9000 -p 9001:9001 \
  -v intlayer-data:/data \
  --env-file ./intlayer.env \
  intlayer/cms-all:latest

docker run -d --name intlayer `
  --restart unless-stopped `
  -p 3000:3000 -p 3100:3100 -p 9000:9000 -p 9001:9001 `
  -v intlayer-data:/data `
  --env-file ./intlayer.env `
  intlayer/cms-all:latest

# Backup (stop the container first so MongoDB's files are consistent)
docker stop intlayer
docker run --rm -v intlayer-data:/data -v "$(pwd)":/backup busybox tar czf /backup/intlayer-data.tar.gz /data
docker start intlayer

# Restore
docker run --rm -v intlayer-data:/data -v "$(pwd)":/backup busybox tar xzf /backup/intlayer-data.tar.gz -C /

                ┌───────────────────┐
 browser ──────▶ │  app        :3000 │ ── SSR ──▶ http://backend:3100
 (localhost)    └───────────────────┘
                ┌───────────────────┐
 browser ──────▶ │  backend    :3100 │
 (localhost)    └─────────┬─────────┘
          ┌───────────────┼───────────────┐
          ▼               ▼               ▼
     mongo:27017     redis:6379      minio:9000 ◀── browser (assets)
     (1-node RS)                     minio:9001

curl -fsSL https://intlayer.org/install.sh | sh -s -- --mode compose

mkdir intlayer && cd intlayer
curl -fsSLO https://raw.githubusercontent.com/aymericzip/intlayer/main/docker/selfhost/docker-compose.yml
curl -fsSL  https://raw.githubusercontent.com/aymericzip/intlayer/main/docker/selfhost/.env.template -o .env
# fill in BETTER_AUTH_SECRET and S3_SECRET_ACCESS_KEY (openssl rand -hex 32)

$env:INTLAYER_MODE = "compose"; irm https://intlayer.org/install.ps1 | iex

mkdir intlayer; cd intlayer
irm https://raw.githubusercontent.com/aymericzip/intlayer/main/docker/selfhost/docker-compose.yml -OutFile docker-compose.yml
irm https://raw.githubusercontent.com/aymericzip/intlayer/main/docker/selfhost/.env.template -OutFile .env
# fill in BETTER_AUTH_SECRET and S3_SECRET_ACCESS_KEY

npx intlayer init infra --mode compose

cd intlayer && docker compose up -d

services:
  backend:
    environment:
      MONGODB_URI: mongodb+srv://user:password@cluster0.xxxxx.mongodb.net/intlayer
      REDIS_URL: rediss://default:password@redis.example.com:6380
      S3_ENDPOINT: https://s3.eu-west-1.amazonaws.com
      S3_PUBLIC_URL: https://intlayer-assets.s3.eu-west-1.amazonaws.com

cd docker/selfhost
docker compose -f docker-compose.yml -f docker-compose.build.yml up -d --build

# Backup one volume (repeat for intlayer_redis-data and intlayer_minio-data)
docker compose stop
docker run --rm -v intlayer_mongo-data:/data -v "$(pwd)":/backup busybox tar czf /backup/mongo-data.tar.gz /data
docker compose start

# Upgrade, volumes are kept
docker compose pull && docker compose up -d

Installationsprogramm-Einstellungen

Ohne --mode (oder INTLAYER_MODE) zeigt das Installationsprogramm ein Menü an: desktop, docker (All-in-One) oder compose. Es liest auch einige Umgebungsvariablen. Da es in die Shell geleitet wird, übergeben Sie diese an die Shell und nicht an curl:

curl -fsSL https://intlayer.org/install.sh | INTLAYER_COMPOSE_DIR=./cms sh -s -- --mode compose

$env:INTLAYER_MODE = "compose"; $env:INTLAYER_COMPOSE_DIR = ".\cms"; irm https://intlayer.org/install.ps1 | iex

Die Portvariablen ändern nur die Host-Seite des Mappings. Die veröffentlichten Images haben http://localhost:3000, http://localhost:3100 und http://localhost:9000 im Dashboard-Bundle kompiliert. Behalten Sie die Standardwerte bei, es sei denn, Sie erstellen eigene Images, siehe Einschränkungen.

Ersteinrichtung

Bei einer neuen Instanz (leere Datenbank) leitet das Öffnen des Dashboards auf die Seite /init weiter:

1. Erstellen Sie das erste Konto. Da die Benutzersammlung leer ist, wird dieses Konto automatisch zum Super-Admin ernannt.
2. Eine Bestätigungs-E-Mail wird über Resend oder Ihr SMTP-Relay gesendet. Die E-Mail-Bestätigung ist obligatorisch, weshalb vor dem Start ein Mailer konfiguriert werden muss.
3. Klicken Sie auf den Link in der E-Mail und melden Sie sich an.

Sobald ein Admin existiert, leitet /init auf die Standard-Anmeldeseite weiter.

Umgebungsvariablen

Beide Docker-Modi lesen dieselbe Datei (intlayer.env für den Container, .env für Compose), die aus docker/selfhost/.env.template generiert wird.

Erforderlich

Durch das Deployment festgelegt

Diese werden durch das Image (All-in-One) oder die Compose-Datei gesetzt und müssen nur bei einer nicht standardmäßigen Topologie überschrieben werden. DOMAIN, APP_URL, BACKEND_URL und S3_PUBLIC_URL sind die Ausnahme: In der env-Datei gesetzt, haben sie in beiden Modi Vorrang (siehe Benutzerdefinierte Domain).

Der Compose-Dienst app erhält zusätzlich INTLAYER_BACKEND_INTERNAL_URL=http://backend:3100: Der Browser erreicht die API über localhost:3100, aber das serverseitige Rendering läuft innerhalb des Compose-Netzwerks und muss den Dienstnamen verwenden.

Benutzerdefinierte Domain

Das Backend liest seine öffentlichen URLs zur Laufzeit, das Dashboard hat sie jedoch einkompiliert: Die veröffentlichten Images intlayer/cms-frontend und intlayer/cms-all funktionieren nur unter http://localhost:3000. Um Intlayer unter Ihrer eigenen Domain bereitzustellen, braucht es daher zwei Dinge, die beide vom Installationsprogramm vorbereitet werden, wenn Sie die Domain-Frage beantworten:

1. Vier Variablen in der env-Datei, die vom Backend gelesen werden (Cookies, E-Mail-Links, OAuth-Callbacks, Asset-URLs) und von docker-compose.build.yml als Build-Argumente verwendet werden:

   intlayer.env

   Inhalt kopieren

   Code kopieren

   Kopieren Sie den Code in die Zwischenablage

   DOMAIN=example.org                          # cookie domain, parent of the hosts below
   APP_URL=https://cms.example.org
   BACKEND_URL=https://back.example.org
   S3_PUBLIC_URL=https://s3.example.org/intlayer
   

2. Ein mit diesen URLs gebautes Dashboard-Image. Docker baut es direkt aus dem Repository, ohne Checkout:

   sh

   Inhalt kopieren

   Code kopieren

   Kopieren Sie den Code in die Zwischenablage

   # Docker Compose: the override reads the build args from .env
   docker compose -f docker-compose.yml -f docker-compose.build.yml up -d --build
   
   # All-in-one
   docker build -f docker/selfhost/Dockerfile \
     --build-arg VITE_DOMAIN=example.org \
     --build-arg VITE_SITE_URL=https://cms.example.org \
     --build-arg VITE_IDE_URL=https://cms.example.org \
     --build-arg VITE_BACKEND_URL=https://back.example.org \
     -t intlayer/cms-all:custom \
     https://github.com/aymericzip/intlayer.git#main
   

Stellen Sie anschließend einen Reverse Proxy mit TLS vor den Container: cms.example.org → Port 3000, back.example.org → 3100, s3.example.org → 9000. Die drei Hosts müssen das DOMAIN-Suffix teilen, da das Session-Cookie darauf beschränkt ist.

Optional (Funktionen fallen ohne sie sauber aus)

Globaler Mailer

Jede transaktionale E-Mail, einschließlich E-Mails außerhalb der Organisation wie Passwort-Resets und Magic Links, läuft über einen von zwei globalen Transporten:

• Resend, unter Verwendung von RESEND_API_KEY.
• SMTP, unter Verwendung der Variablen MAIL_SMTP_*. Sobald MAIL_SMTP_HOST gesetzt ist, wird SMTP verwendet und RESEND_API_KEY ignoriert.

MAIL_PROVIDER wird nur benötigt, um einen Transport zu erzwingen, wenn beide konfiguriert sind (z. B. MAIL_PROVIDER=resend, um Resend beizubehalten, während ein SMTP-Host vorhanden ist).

Rangfolge: Der eigene Mailer einer Organisation (im Dashboard unter Organisation konfiguriert) hat Vorrang vor dem globalen Mailer, der wiederum Vorrang vor dem standardmäßigen Resend-Schlüssel hat.

Verbinden Ihres Intlayer-Projekts

Sobald der Stack läuft, verweisen Sie mit Ihrem Projekt auf das selbst gehostete Backend und Dashboard anstelle von intlayer.org.

Projektkonfiguration

import type { IntlayerConfig } from "intlayer";

const config: IntlayerConfig = {
  editor: {
    clientId: process.env.INTLAYER_CLIENT_ID,
    clientSecret: process.env.INTLAYER_CLIENT_SECRET,

    /**
     * URL of the self-hosted CMS dashboard.
     * Default: https://app.intlayer.org
     */
    cmsURL: process.env.INTLAYER_CMS_URL, // e.g. http://localhost:3000

    /**
     * URL of the self-hosted backend API.
     * Default: https://back.intlayer.org
     */
    backendURL: process.env.INTLAYER_BACKEND_URL, // e.g. http://localhost:3100
  },
};

export default config;

Set the environment variables in your project's .env:

INTLAYER_CMS_URL=http://localhost:3000
INTLAYER_BACKEND_URL=http://localhost:3100
INTLAYER_CLIENT_ID=<your-client-id>
INTLAYER_CLIENT_SECRET=<your-client-secret>

Erstellen Sie Zugangsdaten in Ihrem selbst gehosteten Dashboard unter Projekte → Zugriffsschlüssel unter http://localhost:3000/projects.

@intlayer/api-SDK

Wenn Sie das @intlayer/api-SDK programmatisch verwenden, übergeben Sie backendURL explizit:

import { createIntlayerCMS } from "@intlayer/api";
import { dictionaryEndpoint } from "@intlayer/api/dictionary";

const cms = createIntlayerCMS({
  editor: {
    clientId: process.env.INTLAYER_CLIENT_ID,
    clientSecret: process.env.INTLAYER_CLIENT_SECRET,
    backendURL: process.env.INTLAYER_BACKEND_URL, // http://localhost:3100
  },
});

const { data: dictionaries } = await dictionaryEndpoint(cms).getDictionaries();

Einschränkungen

• Eine benutzerdefinierte Domain erfordert einen Rebuild. Alle für den Browser sichtbaren VITE_*-URLs sind während des Builds in das Dashboard eingebunden, und die veröffentlichten Images (sowie die Desktop-App) werden mit localhost / Intlayer Cloud-Werten ausgeliefert. Standardmäßig muss auf das Dashboard unter http://localhost:3000, die API unter :3100 und MinIO unter :9000 zugegriffen werden; ein Remapping der Host-Ports hat denselben Effekt. Das Installationsprogramm bereitet alles für einen Rebuild aus dem Repository vor, wenn Sie ihm eine Domain angeben (siehe Benutzerdefinierte Domain), der Build selbst dauert jedoch mehrere Minuten. Das Ausrichten der Desktop-App auf ein selbst gehostetes Backend wird nicht unterstützt.
• E-Mail erfordert einen funktionierenden Mailer. Die Ersteinrichtung erzwingt die E-Mail-Verifizierung, daher muss entweder RESEND_API_KEY oder ein SMTP-Relay (MAIL_SMTP_*) konfiguriert werden. Nachdem sich der erste Admin angemeldet hat, kann jede Organisation auch ihren eigenen SMTP- oder Resend-Mailer im Dashboard konfigurieren.
• Die Desktop-App benötigt Node.js auf dem Computer, um ihren eingebetteten Server zu starten.
• Kein Dokumentationsassistent. Der KI-Dokumentationsassistent von intlayer.org (/api/ai/ask, /api/search/doc) basiert auf ca. 130 MB vorberechneter Dokumentations-Embeddings, die die Self-Host-Images nicht mitliefern; diese beiden Routen werden im selbst gehosteten Modus nicht registriert. Die eigenen KI-Funktionen des Dashboards (Übersetzung, Audit, Autovervollständigung, Chat) sind nicht betroffen und benötigen nur OPENAI_API_KEY.

Nützliche Links

• Intlayer CMS-Dokumentation
• Konfigurationsreferenz
• CMS SDK: @intlayer/api
• Releases der Desktop-App
• Docker Hub: intlayer/cms-all, intlayer/cms-frontend, intlayer/cms-backend, gespiegelt auf GHCR unter ghcr.io/aymericzip/intlayer/
• docker/selfhost/: Dockerfile, docker-compose.yml und .env.template