Outline 完整指南：专为工程团队打造的开源 Wiki 与知识库 —— 2026 自托管部署

# docker-compose.yml
version: "3.8"

services:
  outline:
    image: outlinewiki/outline:0.83.0
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=postgres://outline:outline_password@postgres:5432/outline
      - DATABASE_URL_TEST=postgres://outline:outline_password@postgres:5432/outline-test
      - REDIS_URL=redis://redis:6379
      - SECRET_KEY=${SECRET_KEY}
      - UTILS_SECRET=${UTILS_SECRET}
      - URL=https://wiki.yourcompany.com
      - PORT=3000
      - AWS_ACCESS_KEY_ID=minio
      - AWS_SECRET_ACCESS_KEY=minio123
      - AWS_REGION=us-east-1
      - AWS_S3_UPLOAD_BUCKET_URL=http://minio:9000
      - AWS_S3_UPLOAD_BUCKET_NAME=outline
      - AWS_S3_FORCE_PATH_STYLE=true
      - AWS_S3_ACL=private
      - FILE_STORAGE=local
      - OIDC_CLIENT_ID=${OIDC_CLIENT_ID}
      - OIDC_CLIENT_SECRET=${OIDC_CLIENT_SECRET}
      - OIDC_AUTH_URI=${OIDC_AUTH_URI}
      - OIDC_TOKEN_URI=${OIDC_TOKEN_URI}
      - OIDC_USERINFO_URI=${OIDC_USERINFO_URI}
      - OIDC_LOGOUT_URI=${OIDC_LOGOUT_URI}
      - OIDC_DISPLAY_NAME=Google Workspace
      - SLACK_CLIENT_ID=${SLACK_CLIENT_ID}
      - SLACK_CLIENT_SECRET=${SLACK_CLIENT_SECRET}
      - SLACK_VERIFICATION_TOKEN=${SLACK_VERIFICATION_TOKEN}
    depends_on:
      - postgres
      - redis
      - minio
    restart: unless-stopped

  postgres:
    image: postgres:16-alpine
    environment:
      - POSTGRES_USER=outline
      - POSTGRES_PASSWORD=outline_password
      - POSTGRES_DB=outline
    volumes:
      - postgres-data:/var/lib/postgresql/data
    restart: unless-stopped

  redis:
    image: redis:7-alpine
    volumes:
      - redis-data:/data
    restart: unless-stopped

  minio:
    image: minio/minio:RELEASE.2026-04-01T00-00-00Z
    command: server /data --console-address ":9001"
    environment:
      - MINIO_ROOT_USER=minio
      - MINIO_ROOT_PASSWORD=minio123
    volumes:
      - minio-data:/data
    restart: unless-stopped

  minio-createbucket:
    image: minio/mc:latest
    depends_on:
      - minio
    entrypoint: >
      /bin/sh -c "
      sleep 10;
      mc alias set local http://minio:9000 minio minio123;
      mc mb local/outline || true;
      mc anonymous set private local/outline;
      exit 0;
      "

volumes:
  postgres-data:
  redis-data:
  minio-data:

# 生成 256 位密钥
export SECRET_KEY=$(openssl rand -hex 32)

# 生成 utils 密钥
export UTILS_SECRET=$(openssl rand -hex 16)

echo "SECRET_KEY=$SECRET_KEY"
echo "UTILS_SECRET=$UTILS_SECRET"

cat << 'EOF' > .env
SECRET_KEY=REPLACE_WITH_GENERATED_SECRET
UTILS_SECRET=REPLACE_WITH_GENERATED_SECRET
SLACK_CLIENT_ID=
SLACK_CLIENT_SECRET=
SLACK_VERIFICATION_TOKEN=
OIDC_CLIENT_ID=
OIDC_CLIENT_SECRET=
EOF
chmod 600 .env

docker-compose up -d

# 检查所有服务是否健康
docker-compose ps

# 查看日志
docker-compose logs -f outline

OIDC_CLIENT_ID=xxx.apps.googleusercontent.com
OIDC_CLIENT_SECRET=GOCSPX-xxx
OIDC_AUTH_URI=https://accounts.google.com/o/oauth2/v2/auth
OIDC_TOKEN_URI=https://oauth2.googleapis.com/token
OIDC_USERINFO_URI=https://openidconnect.googleapis.com/v1/userinfo
OIDC_LOGOUT_URI=https://accounts.google.com/logout

docker-compose restart outline

# 在全新的 Ubuntu 24.04 Droplet（$6/月）上
sudo apt update && sudo apt install -y docker.io docker-compose-plugin

# 克隆并启动
git clone https://github.com/outline/outline.git
cd outline
# 复制上面的 docker-compose.yml，配置 .env，然后：
docker compose up -d

_display_name: Outline Wiki
features:
  bot_user:
    display_name: Outline
    always_online: true
  slash_commands:
    - command: /outline
      url: https://wiki.yourcompany.com/api/hooks.slack
      description: 搜索你的知识库
      usage_hint: "[search query]"
      should_escape: false
oauth_config:
  redirect_urls:
    - https://wiki.yourcompany.com/auth/slack.callback
  scopes:
    bot:
      - commands
      - links:read
      - links:write
settings:
  event_subscriptions:
    request_url: https://wiki.yourcompany.com/api/hooks.slack
    bot_events:
      - link_shared
  org_deploy_enabled: true
  socket_mode_enabled: false

# 列出所有 Collection
curl -X GET "https://wiki.yourcompany.com/api/collections" \
  -H "Authorization: Bearer YOUR_API_TOKEN"

# 创建新文档
curl -X POST "https://wiki.yourcompany.com/api/documents.create" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Incident Response Runbook",
    "text": "## Overview\n\nThis document covers...",
    "collectionId": "123e4567-e89b-12d3-a456-426614174000",
    "publish": true
  }'

# 搜索文档
curl -X POST "https://wiki.yourcompany.com/api/documents.search" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query": "rollback procedure"}'

#!/bin/bash
# .github/workflows/publish-docs.yml
name: Publish API Docs to Outline

on:
  push:
    branches: [main]
    paths:
      - 'docs/**'

jobs:
  publish:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Publish to Outline
        run: |
          DOCS=$(cat docs/api-reference.md)
          curl -X POST "https://wiki.yourcompany.com/api/documents.update" \
            -H "Authorization: Bearer ${{ secrets.OUTLINE_API_TOKEN }}" \
            -H "Content-Type: application/json" \
            -d "{
              \"id\": \"DOC_ID_HERE\",
              \"text\": $(echo "$DOCS" | jq -R -s .),
              \"append\": false
            }"

# 从 Notion 导出：
# Settings & Members → Settings → Export All Workspace Content → Export as Markdown

# 从 Confluence 导出：
# Space Tools → Content Tools → Export → XML format

# 导入 Outline：
# Collection → Import → Upload Markdown/ZIP file
# Outline 保留标题结构并将 Notion 数据库转换为表格

# /etc/nginx/sites-available/outline
server {
    listen 80;
    server_name wiki.yourcompany.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name wiki.yourcompany.com;

    ssl_certificate /etc/letsencrypt/live/yourcompany.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/yourcompany.com/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_prefer_server_ciphers on;

    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_read_timeout 86400;
    }

    location /realtime {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

#!/bin/bash
# /opt/backup/outline-backup.sh
set -euo pipefail

BACKUP_DIR="/backups/outline"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
mkdir -p "$BACKUP_DIR"

# 备份 PostgreSQL
docker exec outline-postgres-1 pg_dump -U outline outline > \
  "$BACKUP_DIR/outline_db_$TIMESTAMP.sql"

# 备份上传的文件（MinIO S3）
docker exec outline-minio-1 mc mirror local/outline \
  "local/backup-outline-files-$TIMESTAMP"

# 压缩
zip -r "$BACKUP_DIR/outline_full_$TIMESTAMP.zip" \
  "$BACKUP_DIR/outline_db_$TIMESTAMP.sql" \
  "/var/lib/docker/volumes/outline_minio-data/_data"

# 上传到 S3
aws s3 cp "$BACKUP_DIR/outline_full_$TIMESTAMP.zip" \
  s3://yourcompany-backups/outline/

# 只保留最近 14 个备份
ls -t "$BACKUP_DIR"/outline_full_*.zip | tail -n +15 | xargs -r rm

echo "Backup completed: outline_full_$TIMESTAMP.zip"

# 每天凌晨 3 点运行
0 3 * * * /opt/backup/outline-backup.sh >> /var/log/outline-backup.log 2>&1

# docker-compose.monitoring.yml
services:
  prometheus:
    image: prom/prometheus:v2.51.0
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus-data:/prometheus
    ports:
      - "9090:9090"
    restart: unless-stopped

  grafana:
    image: grafana/grafana:10.4.0
    volumes:
      - grafana-data:/var/lib/grafana
      - ./grafana-dashboards:/etc/grafana/provisioning/dashboards
    ports:
      - "3001:3000"
    restart: unless-stopped

  node-exporter:
    image: prom/node-exporter:v1.7.0
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /:/rootfs:ro
    command:
      - '--path.procfs=/host/proc'
      - '--path.rootfs=/rootfs'
      - '--path.sysfs=/host/sys'
    restart: unless-stopped

volumes:
  prometheus-data:
  grafana-data:

# 为 Backblaze B2 添加 .env 配置
AWS_ACCESS_KEY_ID=YOUR_B2_KEY_ID
AWS_SECRET_ACCESS_KEY=YOUR_B2_APPLICATION_KEY
AWS_REGION=us-west-002
AWS_S3_UPLOAD_BUCKET_URL=https://s3.us-west-002.backblazeb2.com
AWS_S3_UPLOAD_BUCKET_NAME=your-outline-bucket
AWS_S3_FORCE_PATH_STYLE=false

# docker-compose.prod.yml — 使用生产配置扩展基础配置
services:
  outline:
    image: outlinewiki/outline:0.83.0
    environment:
      - NODE_ENV=production
      - FORCE_HTTPS=true
      - RATE_LIMITER_ENABLED=true
      - DEFAULT_LANGUAGE=en_US
      - WEB_CONCURRENCY=2
    deploy:
      replicas: 2
      resources:
        limits:
          memory: 1G
        reservations:
          memory: 512M
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/api/utils.health"]
      interval: 30s
      timeout: 10s
      retries: 3