Auto-hospedagem do Intlayer

O Intlayer pode ser executado inteiramente na sua própria infraestrutura — nenhuma conta Intlayer Cloud é necessária. Um único comando inicializa uma stack pronta para produção:

Um comando instala tudo:

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

O instalador baixa um docker-compose.yml e um .env, gera automaticamente os segredos necessários e inicia todos os containers com docker compose up -d.

A única dependência externa é MongoDB: o backend se conecta a um cluster MongoDB Atlas, que você fornece. Tudo mais é executado dentro do container.

Sumário

Arquitetura

                ┌─────────────────────────────┐
 browser ──────▶ │  app  (TanStack Start)  :3000│ ──┐
                └─────────────────────────────┘   │ VITE_BACKEND_URL
                ┌─────────────────────────────┐   │
                │  backend (Fastify/Bun)  :3100│ ◀─┘
                └──────────────┬──────────────┘
          ┌──────────┬─────────┼──────────┬───────────┐
          ▼          ▼         ▼          ▼           ▼
     mongo:27017  redis:6379  minio:9000  mailpit:1025  Chromium
     (1-node RS)             (S3 API)     (SMTP)        (in-image)
                             minio:9001   mailpit:8025
                             (console)    (web UI)

O Chromium (usado para a geração de screenshots do Puppeteer) é empacotado dentro da imagem do backend — nenhum container separado é necessário.

Pré-requisitos

• Docker ≥ 24 e Docker Compose ≥ v2. Se algum deles estiver faltando, o instalador exibe o link de instalação e sai.
• Portas 3000, 3100, 8025, 9000 e 9001 disponíveis no host.
• Um host Linux ou macOS (ou WSL2 no Windows).

Tudo o resto — Bun, Redis, MinIO, Chromium — é enviado dentro da imagem.

Início rápido

1. Executar o instalador

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

Ele verifica se o Docker está instalado e em execução, escreve ./intlayer.env com BETTER_AUTH_SECRET e S3_SECRET_ACCESS_KEY já gerados, e baixa a imagem. Ele não inicia o contêiner — o backend não pode inicializar sem suas credenciais de banco de dados.

Executar o instalador novamente é seguro: um intlayer.env existente nunca será sobrescrito, então ele funciona também como o caminho para atualização.

2. Preencha suas credenciais

Abra intlayer.env e complete os valores marcados como TODO:

DB_ID=<atlas-user>
DB_MDP=<atlas-password>
DB_CLUSTER=<cluster>.xxxxx.mongodb.net
RESEND_API_KEY=<your-resend-key>

O arquivo também contém blocos comentados para recursos opcionais — SMTP mailer, OPENAI_API_KEY e os provedores OAuth. Descomente o que você precisar.

O arquivo é lido por docker run --env-file, que não remove aspas e trata tudo após = como o valor. Escreva valores simples e mantenha comentários em suas próprias linhas.

3. Iniciar o container

Este é o comando que o instalador imprime quando termina:

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 \
  ghcr.io/aymericzip/intlayer-selfhost:latest

Em seguida, abra http://localhost:3000. O primeiro boot inicializa os datastores, então aguarde um minuto.

O dashboard é servido em localhost. Consulte Limitações — domínios personalizados não são suportados pela imagem publicada.

Configurações do instalador

O instalador lê algumas variáveis de ambiente. Como é canalizado para sh, passe-as para o shell em vez de para curl:

curl -fsSL https://intlayer.org/install.sh | INTLAYER_ENV_FILE=./config/intlayer.env sh

As quatro variáveis de porta apenas mudam o lado host do mapeamento impresso no comando docker run. A imagem publicada tem http://localhost:3000, http://localhost:3100 e http://localhost:9000 compilados no pacote do painel no momento da compilação, portanto remapeá-los deixa o navegador apontando para as portas antigas. Mantenha os padrões a menos que esteja criando sua própria imagem — veja Limitações.

Início rápido

O que o instalador faz:

1. Verifica se docker e docker compose estão presentes.
2. Baixa docker-compose.yml e .env.example para ./intlayer/.
3. Se nenhum .env existir, copia o exemplo e gera segredos aleatórios para BETTER_AUTH_SECRET, S3_ACCESS_KEY_ID e S3_SECRET_ACCESS_KEY via openssl rand.
4. Executa docker compose pull + docker compose up -d.
5. Imprime as URLs: dashboard :3000, API :3100, UI de e-mail :8025, console MinIO :9001.

Após a stack estar ativa, abra http://localhost:3000 e crie sua primeira conta.

Serviços

A porta 9000 do MinIO deve ser acessível pelo navegador porque os ativos carregados (avatares, screenshots) são carregados diretamente de S3_PUBLIC_URL=http://localhost:9000/intlayer.

Variáveis de ambiente

Obrigatório

Obrigatórias (auto-geradas ou solicitadas)

Opcionais (recursos são degradados graciosamente quando ausentes)

Global mailer

Por padrão, todos os emails transacionais são enviados através do Resend usando RESEND_API_KEY. Implantações auto-hospedadas podem, em vez disso, rotear todos os emails — incluindo emails não-organizacionais, como redefinições de senha e magic links — através de um mailer global configurado com variáveis de ambiente.

Configure MAIL_PROVIDER para ativá-lo. Quando não configurado, o mailer padrão do Resend é usado.

Precedência: o próprio mailer de uma organização (configurado a partir do dashboard Organization) tem prioridade sobre o mailer global, que por sua vez tem prioridade sobre a chave padrão do Resend.

Conectando seu projeto Intlayer

Uma vez que a stack esteja em execução, aponte seu projeto para o backend e dashboard auto-hospedados em vez de intlayer.org.

Configuração do projeto

import type { IntlayerConfig } from "intlayer";

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

    /**
     * URL do dashboard CMS auto-hospedado.
     * Padrão: https://app.intlayer.org
     */
    cmsURL: process.env.INTLAYER_CMS_URL, // e.g. http://localhost:3000

    /**
     * URL da API do backend auto-hospedado.
     * Padrão: https://back.intlayer.org
     */
    backendURL: process.env.INTLAYER_BACKEND_URL, // e.g. http://localhost:3100
  },
};

export default config;

Defina as variáveis de ambiente no arquivo .env do seu projeto:

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

Crie credenciais de acesso no seu dashboard auto-hospedado em Projetos → Chaves de acesso em http://localhost:3000/projects.

SDK @intlayer/api

Ao usar o SDK @intlayer/api programaticamente, passe backendURL explicitamente:

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

Atualizando

Isso baixa as imagens mais recentes e reinicia os containers com docker compose pull && docker compose up -d. Os volumes existentes (mongo-data, redis-data, minio-data) são preservados — sem perda de dados.

docker compose pull
docker compose up -d

Backup e restauração

Todos os dados persistentes residem em três volumes Docker nomeados.

Backup

docker run --rm \
  -v intlayer_mongo-data:/data \
  -v "$(pwd)":/backup \
  busybox tar czf /backup/mongo-data.tar.gz /data

docker run --rm \
  -v intlayer_redis-data:/data \
  -v "$(pwd)":/backup \
  busybox tar czf /backup/redis-data.tar.gz /data

docker run --rm \
  -v intlayer_minio-data:/data \
  -v "$(pwd)":/backup \
  busybox tar czf /backup/minio-data.tar.gz /data

Restauração

docker run --rm \
  -v intlayer_mongo-data:/data \
  -v "$(pwd)":/backup \
  busybox tar xzf /backup/mongo-data.tar.gz -C /

# Repita para redis-data e minio-data

Limitações

• MongoDB deve ser externo (Atlas). O backend conecta apenas via mongodb+srv:// (construído a partir de DB_ID / DB_MDP / DB_CLUSTER), então um simples mongodb://host:27017 — incluindo o mongod incluído no container — não pode ser usado. Forneça um cluster MongoDB Atlas.
• Sem domínio personalizado. Todas as URLs VITE_* voltadas para o navegador são inseridas no app em tempo de construção, e a imagem publicada é enviada com valores localhost. O dashboard deve ser acessado em http://localhost:3000; servir em um domínio público exigiria reconstruir a imagem com as URLs de destino incorporadas e não é suportado por padrão.
• Email requer um mailer funcionando. A configuração da primeira execução impõe verificação de email, portanto, RESEND_API_KEY ou um mailer SMTP global (MAIL_PROVIDER=smtp + MAIL_SMTP_*) deve ser configurado. Após o primeiro admin se conectar, cada organização também pode configurar seu próprio mailer SMTP ou Resend no dashboard.

Solução de problemas

Backend em loop de falha na primeira inicialização

MongoDB e Redis devem estar saudáveis antes que o backend possa iniciar. O arquivo compose usa depends_on com condition: service_healthy. Se você notar reinícios repetidos do backend, verifique se os healthchecks do mongo e redis estão passando:

docker compose ps
docker compose logs mongo
docker compose logs redis

Procure por MongoDB connection error próximo ao topo do log.

Dashboard não consegue acessar a API

Verifique se VITE_BACKEND_URL corresponde à URL onde o backend é acessível a partir do navegador (não da rede Docker). Se você alterou a porta do backend ou adicionou um proxy reverso, reconstrua a imagem do dashboard:

Bucket MinIO ausente

Se o serviço minio-init de execução única não foi executado (ou executou antes que o MinIO estivesse pronto), crie o bucket manualmente:

docker compose run --rm minio-init

Links úteis

• Documentação do Intlayer CMS
• Referência de configuração
• SDK do CMS — @intlayer/api
• Docker Image (aymercizip/intlayer-selfhost)