Auto-hébergement d'Intlayer

Intlayer peut fonctionner sur votre propre infrastructure, aucun compte Intlayer Cloud requis. Trois configurations sont disponibles, toutes gérées par le même installateur (install.sh, install.ps1 sur Windows ou npx intlayer init infra) :

Table des matières

Images et paquets publiés

Les trois images sont construites à partir du même docker/selfhost/Dockerfile et publiées à chaque version. La stack Compose télécharge également les images officielles mongo:8, redis:8-alpine et quay.io/minio/minio.

Configuration

L'installateur vous demande quelle configuration vous souhaitez, vérifie les prérequis (en proposant d'installer Docker), écrit le fichier d'environnement avec les secrets déjà générés et télécharge les images. Il ne démarre rien de lui-même : les modes Docker nécessitent d'abord un service d'e-mail, il termine donc en affichant la commande à exécuter. Le réexécuter est sans danger : un fichier d'environnement existant n'est jamais écrasé, ce qui en fait également le moyen de mise à niveau.

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=<votre-clé-resend>

# Option B : SMTP (prend le relais dès que MAIL_SMTP_HOST est défini)
MAIL_SMTP_HOST=smtp.example.com
MAIL_SMTP_PORT=587
MAIL_SMTP_USER=<utilisateur>
MAIL_SMTP_PASSWORD=<mot-de-passe>
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

# Sauvegarde (arrêtez d'abord le conteneur pour que les fichiers de MongoDB soient cohérents)
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

# Restauration
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
# renseignez BETTER_AUTH_SECRET et 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
# renseignez BETTER_AUTH_SECRET et 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

# Sauvegarder un volume (répéter pour intlayer_redis-data et 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

# Mise à niveau, les volumes sont conservés
docker compose pull && docker compose up -d

Paramètres de l'installateur

Sans --mode (ou INTLAYER_MODE), l'installateur affiche un menu : desktop, docker (tout-en-un) ou compose. Il lit également quelques variables d'environnement. Comme il est transmis dans le shell via un pipe, passez-les au shell plutôt qu'à 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

Les variables de port ne modifient que le côté hôte du mappage. Les images publiées intègrent http://localhost:3000, http://localhost:3100 et http://localhost:9000 compilés dans le bundle du tableau de bord, conservez donc les valeurs par défaut à moins de construire vos propres images, voir Limitations.

Configuration initiale

Sur une nouvelle instance (base de données vide), l'ouverture du tableau de bord vous redirige vers la page /init :

1. Créez le premier compte. La collection des utilisateurs étant vide, ce compte est automatiquement promu super administrateur.
2. Un e-mail de vérification est envoyé via Resend ou votre relais SMTP. La vérification de l'e-mail est obligatoire, c'est pourquoi un service de messagerie doit être configuré avant de démarrer.
3. Cliquez sur le lien dans l'e-mail, puis connectez-vous.

Une fois qu'un administrateur existe, /init redirige vers la page de connexion standard.

Variables d'environnement

Les deux modes Docker lisent le même fichier (intlayer.env pour le conteneur, .env pour Compose), généré à partir de docker/selfhost/.env.template.

Obligatoires

Fixées par le déploiement

Celles-ci sont définies par l'image (tout-en-un) ou par le fichier compose, et ne nécessitent d'être surchargées que pour une topologie personnalisée. DOMAIN, APP_URL, BACKEND_URL et S3_PUBLIC_URL font exception : définies dans le fichier env, elles prévalent dans les deux modes (voir Domaine personnalisé).

Le service app de Compose reçoit en plus INTLAYER_BACKEND_INTERNAL_URL=http://backend:3100 : le navigateur accède à l'API sur localhost:3100, mais le rendu côté serveur s'exécute à l'intérieur du réseau Compose et doit utiliser le nom du service.

Domaine personnalisé

Le backend lit ses URL publiques à l'exécution, mais le tableau de bord les a compilées en dur : les images publiées intlayer/cms-frontend et intlayer/cms-all ne fonctionnent que sur http://localhost:3000. Servir Intlayer sur votre propre domaine demande donc deux choses, toutes deux préparées par l'installateur lorsque vous répondez à la question du domaine :

1. Quatre variables dans le fichier env, lues par le backend (cookies, liens des e-mails, callbacks OAuth, URL des ressources) et utilisées comme arguments de build par docker-compose.build.yml :

   intlayer.env

   Copier le contenu

   Copier le code

   Copier le code dans le presse-papiers

   DOMAIN=example.org                          # domaine du cookie, parent des hôtes ci-dessous
   APP_URL=https://cms.example.org
   BACKEND_URL=https://back.example.org
   S3_PUBLIC_URL=https://s3.example.org/intlayer
   

2. Une image du tableau de bord construite avec ces URL. Docker la construit directement depuis le dépôt, sans clone nécessaire :

   sh

   Copier le contenu

   Copier le code

   Copier le code dans le presse-papiers

   # Docker Compose : la surcharge lit les arguments de build depuis .env
   docker compose -f docker-compose.yml -f docker-compose.build.yml up -d --build
   
   # Tout-en-un
   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
   

Placez ensuite un reverse proxy avec TLS devant le conteneur : cms.example.org → port 3000, back.example.org → 3100, s3.example.org → 9000. Les trois hôtes doivent partager le suffixe DOMAIN, puisque le cookie de session y est limité.

Optionnelles (les fonctionnalités se dégradent en douceur en leur absence)

Service d'e-mail global

Chaque e-mail transactionnel, y compris les e-mails hors organisation tels que les réinitialisations de mot de passe et liens magiques, passe par l'un des deux transports globaux :

• Resend, en utilisant RESEND_API_KEY.
• SMTP, en utilisant les variables MAIL_SMTP_*. Dès que MAIL_SMTP_HOST est défini, SMTP est utilisé et RESEND_API_KEY est ignoré.

MAIL_PROVIDER n'est nécessaire que pour forcer un transport lorsque les deux sont configurés (par exemple MAIL_PROVIDER=resend pour conserver Resend alors qu'un hôte SMTP est présent).

Priorité : le service d'e-mail propre à une organisation (configuré depuis le tableau de bord de l'Organisation) a la priorité sur le service global, qui lui-même a la priorité sur la clé Resend par défaut.

Connecter votre projet Intlayer

Une fois la stack lancée, faites pointer votre projet vers le backend et le tableau de bord auto-hébergés plutôt que intlayer.org.

Configuration du projet

import type { IntlayerConfig } from "intlayer";

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

    /**
     * URL du tableau de bord CMS auto-hébergé.
     * Par défaut : https://app.intlayer.org
     */
    cmsURL: process.env.INTLAYER_CMS_URL, // ex. http://localhost:3000

    /**
     * URL de l'API backend auto-hébergée.
     * Par défaut : https://back.intlayer.org
     */
    backendURL: process.env.INTLAYER_BACKEND_URL, // ex. http://localhost:3100
  },
};

export default config;

Définissez les variables d'environnement dans le fichier .env de votre projet :

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

Créez des identifiants d'accès dans votre tableau de bord auto-hébergé sous Projets → Clés d'accès à l'adresse http://localhost:3000/projects.

SDK @intlayer/api

Lorsque vous utilisez le SDK @intlayer/api par programmation, passez backendURL explicitement :

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();

Limitations

• Un domaine personnalisé implique une reconstruction. Toutes les URL VITE_* destinées au navigateur sont intégrées au tableau de bord lors de la construction, et les images publiées (ainsi que l'application de bureau) sont fournies avec les valeurs localhost / Intlayer Cloud. Par défaut, le tableau de bord doit être accessible sur http://localhost:3000, l'API sur :3100 et MinIO sur :9000 ; remapper les ports de l'hôte a le même effet. L'installateur prépare tout pour une reconstruction depuis le dépôt lorsque vous lui indiquez un domaine (voir Domaine personnalisé), mais la construction elle-même prend plusieurs minutes. Faire pointer l'application de bureau vers un backend auto-hébergé n'est pas pris en charge.
• Les e-mails nécessitent un service de messagerie fonctionnel. La configuration initiale impose la vérification par e-mail, de sorte que soit RESEND_API_KEY, soit un relais SMTP (MAIL_SMTP_*) doit être configuré. Une fois le premier administrateur connecté, chaque organisation peut également configurer son propre service SMTP ou Resend depuis le tableau de bord.
• L'application de bureau nécessite Node.js sur la machine pour démarrer son serveur intégré.
• Pas d'assistant de documentation. L'assistant IA de documentation d'intlayer.org (/api/ai/ask, /api/search/doc) repose sur environ 130 Mo d'embeddings de documentation pré-calculés que les images auto-hébergées n'embarquent pas ; ces deux routes ne sont pas enregistrées en mode auto-hébergé. Les fonctionnalités d'IA propres au tableau de bord (traduction, audit, autocomplétion, chat) ne sont pas affectées et nécessitent uniquement OPENAI_API_KEY.

Liens utiles

• Documentation Intlayer CMS
• Référence de configuration
• SDK CMS : @intlayer/api
• Releases de l'application de bureau
• Docker Hub : intlayer/cms-all, intlayer/cms-frontend, intlayer/cms-backend, miroir sur GHCR sous ghcr.io/aymericzip/intlayer/
• docker/selfhost/ : Dockerfile, docker-compose.yml et .env.template