As páginas do Outline em si não são pesadas; o que realmente consome recursos é o PostgreSQL, o Redis, a busca em texto completo e o processamento de anexos. Equipes pequenas podem planejar a partir dos seguintes pontos de partida:

Se o VPS tiver apenas 1GB de memória, primeiro conclua a otimização de ZRAM e Swap para VPS com pouca memória e depois implante o Outline. O Swap só alivia os picos de inicialização; não substitui a memória necessária para a operação de longo prazo.

Aponte os registros A/AAAA de docs.example.com para o VPS e instale o Docker Compose:

sudo apt update
sudo apt install -y ca-certificates curl openssl
curl -fsSL https://get.docker.com | sudo sh
sudo usermod -aG docker "$USER"
newgrp docker

sudo mkdir -p /opt/outline/{data,postgres,redis}
sudo chown -R "$USER":"$USER" /opt/outline
cd /opt/outline

Abra apenas SSH, 80 e 443. Não mapeie a porta 5432 do PostgreSQL nem a 6379 do Redis para a internet pública.

O Outline exige pelo menos SECRET_KEY e UTILS_SECRET. Use valores aleatórios; não copie exemplos da internet:

openssl rand -hex 32
openssl rand -hex 32

Crie .env:

URL=https://docs.example.com
PORT=3000
FORCE_HTTPS=true
SECRET_KEY=替换为第一条随机值
UTILS_SECRET=替换为第二条随机值

DATABASE_URL=postgres://outline:替换数据库密码@postgres:5432/outline
REDIS_URL=redis://redis:6379

POSTGRES_USER=outline
POSTGRES_PASSWORD=替换数据库密码
POSTGRES_DB=outline

# OAuth 以 GitHub 为例，生产环境应使用组织级 OAuth App
OIDC_CLIENT_ID=
OIDC_CLIENT_SECRET=
OIDC_AUTH_URI=
OIDC_TOKEN_URI=
OIDC_USERINFO_URI=
OIDC_LOGOUT_URI=
OIDC_USERNAME_CLAIM=preferred_username
OIDC_DISPLAY_NAME=公司账号

O Outline não é adequado para abrir diretamente o "cadastro livre para qualquer pessoa". Antes de conectar o OAuth, mantenha o site dentro de uma VPN, controle de acesso ou ambiente de teste temporário.

Crie compose.yml:

services:
  outline:
    image: outlinewiki/outline:latest
    container_name: outline
    restart: unless-stopped
    env_file: .env
    command: sh -c "yarn sequelize:migrate --env production-ssl-disabled && yarn start"
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
    ports:
      - "127.0.0.1:3000:3000"
    volumes:
      - ./data:/var/lib/outline/data

  postgres:
    image: postgres:16
    container_name: outline-postgres
    restart: unless-stopped
    environment:
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: ${POSTGRES_DB}
    volumes:
      - ./postgres:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
      interval: 10s
      timeout: 5s
      retries: 10

  redis:
    image: redis:7-alpine
    container_name: outline-redis
    restart: unless-stopped
    command: redis-server --appendonly yes
    volumes:
      - ./redis:/data
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 10

Inicie e verifique os logs:

docker compose up -d
docker compose ps
docker compose logs --tail=100 outline

A primeira inicialização executa as migrações do banco de dados. Se outline encerrar repetidamente, verifique primeiro docker compose logs outline, focando na URL, nos segredos, na senha do banco de dados e no endereço de callback do OAuth; não exclua diretamente o diretório de dados do PostgreSQL.

O Outline exige HTTPS e cabeçalhos Host corretos; caso contrário, callbacks de login, URLs de anexos e cookies tendem a falhar. Após instalar o Caddy, escreva o seguinte no Caddyfile:

docs.example.com {
    reverse_proxy 127.0.0.1:3000
}

O Caddy solicitará os certificados automaticamente. Após modificar, verifique:

sudo caddy validate --config /etc/caddy/Caddyfile
sudo systemctl reload caddy
curl -I https://docs.example.com

Se você ainda não tem um ponto de entrada de proxy reverso, consulte Configurar HTTPS automático com Caddy em um VPS. Não exponha a porta 3000 do Outline diretamente à internet pública.

Usando um provedor de identidade compatível com OIDC como exemplo, crie um aplicativo no painel de administração e preencha o endereço de callback:

https://docs.example.com/auth/oidc.callback

Escreva o client ID, o Secret e as quatro URLs OIDC em .env e reinicie:

docker compose up -d --force-recreate outline
docker compose logs -f outline

Se após o login você voltar à página inicial ou aparecer redirect_uri mismatch, verifique cada item:

• Se o endereço de callback registrado no provedor usa exatamente HTTPS;
• Se URL corresponde ao domínio acessado pelo navegador;
• Se o Caddy encaminha o Host e o protocolo originais;
• Se os endereços de issuer, userinfo e logout do OIDC pertencem ao mesmo tenant.

Antes de alterar os parâmetros do OAuth, mantenha um caminho de login de administrador funcional para evitar bloquear todos os administradores fora do site.

Durante os testes você pode usar ./data:/var/lib/outline/data, mas uma falha de disco em uma única máquina perderá tanto o banco de dados quanto os anexos. Para produção, recomenda-se mais o armazenamento compatível com S3, por exemplo o armazenamento de objetos MinIO em VPS implantado anteriormente, mantendo anexos e banco de dados guardados separadamente.

Seja usando um diretório local ou S3, restrinja as permissões:

chmod 600 /opt/outline/.env
sudo chown -R 1001:1001 /opt/outline/data

Não configure o bucket de anexos com escrita pública. Os links de download do frontend devem ser gerados pela aplicação, e a Secret Key deve ficar apenas em variáveis de ambiente do lado do servidor.

O banco de dados é o alvo de backup mais importante. Exporte o PostgreSQL diariamente e salve ao mesmo tempo .env, o arquivo Compose e os anexos:

mkdir -p /opt/outline/backups
docker compose exec -T postgres pg_dump -U "$POSTGRES_USER" "$POSTGRES_DB" | gzip > /opt/outline/backups/outline-$(date +%F).sql.gz
tar -czf /opt/outline/backups/outline-config-$(date +%F).tar.gz .env compose.yml

Não mantenha os backups apenas no mesmo VPS. Você pode combinar o guia de simulação de backup e restauração em VPS para sincronizar o arquivo compactado fora do site e restaurá-lo periodicamente uma vez em uma instância temporária.

Antes de atualizar, fixe a versão atual da imagem e faça backup:

docker compose pull
docker compose up -d
docker compose logs --tail=200 outline

Se a migração da nova versão falhar, não execute repetidamente comandos destrutivos; preserve os logs, faça rollback para a tag de imagem anterior e restaure a partir do backup do banco de dados em uma instância isolada para verificar.

• Não inclua .env no Git; guarde os segredos em um gerenciador de senhas.
• PostgreSQL, Redis e 3000 devem escutar apenas no localhost ou na rede interna do Docker.
• Os callbacks do OAuth devem permitir apenas o domínio oficial; desative o cadastro de autoatendimento desnecessário.
• Atualize os patches de segurança do sistema semanalmente e faça backup do banco de dados antes de cada atualização do Outline.
• Mantenha pelo menos uma cópia fora do site do banco de dados e dos anexos, e realize simulações de restauração.
• O painel de administração pode ainda ser colocado em uma rede privada WireGuard, Tailscale ou Headscale.

A operação estável do Outline depende de quatro coisas: persistência do PostgreSQL, disponibilidade do Redis, callbacks HTTPS corretos e backups que realmente possam ser restaurados. Testes pessoais podem executar três contêineres na mesma máquina; a produção de equipe deve pelo menos incluir o banco de dados e os anexos em backups fora do site, e verificar o caminho de migração e rollback antes de atualizar.