lobehub/docs/self-hosting/server-database/docker-compose.zh-CN.mdx

---
title: 通过 Docker Compose 部署 LobeChat
description: 学习如何使用 Docker Compose 部署 LobeChat 服务，包括各种服务的配置教程。
tags:
  - Docker Compose
  - LobeChat
  - Docker 容器
  - 部署指引
---

# 使用 Docker Compose 部署 LobeChat 服务端数据库版本

<div style={{display:"flex", gap: 4}}>
  [![][docker-release-shield]][docker-release-link]

  [![][docker-size-shield]][docker-size-link]

  [![][docker-pulls-shield]][docker-pulls-link]
</div>

<Callout type="info">
  本文已经假定你了解了 LobeChat 服务端数据库版本（下简称 DB
  版）的部署基本原理和流程，因此只包含核心环境变量配置的内容。如果你还不了解 LobeChat DB
  版的部署原理，请先查阅 [使用服务端数据库部署](/zh/docs/self-hosting/server-database) 。
</Callout>

<Callout type="warning">
  由于无法使用 Docker 环境变量暴露 `NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY`，使用 Docker / Docker Compose
  部署 LobeChat 时，你不能使用 Clerk 作为登录鉴权服务。

  如果你确实需要 Clerk 作为登录鉴权服务，你可以考虑使用 Vercel 部署或者自行构建镜像。
</Callout>

一般来讲，想要完整的运行 LobeChat 数据库版本，你需要至少拥有如下四个服务

- LobeChat 数据库版本自身
- 带有 PGVector 插件的 PostgreSQL 数据库
- 支持 S3 协议的对象存储服务
- 受 LobeChat 支持的 SSO 登录鉴权服务

这些服务可以通过自建或者在线云服务组合搭配，以满足不同层次的部署需求。

本文中，我们提供了完全基于开源自建服务的 Docker Compose 配置，你可以直接使用这份配置文件来启动 LobeChat 数据库版本，也可以对之进行修改以适应你的需求。

我们默认使用 [MinIO](https://github.com/minio/minio) 作为本地 S3 对象存储服务，使用 [Casdoor](https://github.com/casdoor/casdoor) 作为本地鉴权服务。

## 快速启动

为方便快速上手，这一章使用 `docker-compose/local` 目录中的 `docker-compose.yml` 配置文件，启动后的 LobeChat 应用运行在 `http://localhost:3210`，可在本地运行。

<Callout type="warning">
  为了快速上手，此 `docker-compose.yml` 内置了大量的 Secret/Password
  的敏感字段配置，仅适用于快速演示或个人本地使用。请勿直接用于线上生产环境！否则遇到安全问题请自行负责！
</Callout>

<Steps>
  ### 一键启动脚本

  新建一个 `lobe-chat-db` 目录，用于存放你的配置文件和后续的数据库文件。

  ```sh
  mkdir lobe-chat-db
  cd lobe-chat-db
  ```

  我们提供了一个一键启动脚本 `setup.sh`，可以自动使用默认配置并启动服务：

  ```sh
  bash <(curl -fsSL https://raw.githubusercontent.com/lobehub/lobe-chat/HEAD/docker-compose/local/setup.sh) -f -l zh_CN
  ```

  ### 启动 Docker

  ```sh
  docker compose up -d
  ```

  默认登录账号即 Casdoor 的默认账号，账号名 `admin`，密码 `123`

  ### 检查日志

  ```sh
  docker logs -f lobe-chat
  ```

  如果你在容器中看到了以下日志，则说明已经启动成功：

  ```log
  [Database] Start to migration...
  ✅ database migration pass.
  -------------------------------------
    ▲ Next.js 14.x.x
    - Local:        http://localhost:3210
    - Network:      http://0.0.0.0:3210

   ✓ Starting...
   ✓ Ready in 95ms
  ```
</Steps>

至此，你已经成功部署了 LobeChat 数据库版本，你可以通过 `http://localhost:3210` 访问你的 LobeChat 服务。

如果你遇到问题，请尝试查看 Docker 日志和控制台日志进行排查。

## 发布到生产（IP 模式）

下文假设局域网 / 公网需要运行 LobeChat 服务的机器 IP 为 `your_server_ip`。

想要通过局域网 IP 访问，你需要首先按照本地启动运行：

```sh
bash <(curl -fsSL https://raw.githubusercontent.com/lobehub/lobe-chat/HEAD/docker-compose/local/setup.sh) -f -l zh_CN
docker compose up -d
```

接着，你需要修改下载下来的 `docker-compose.yml` 文件，执行一次全文替换，将 `localhost` 替换为 `your_server_ip`，随后重新启动：

```sh
sed -i 's/localhost/your_server_ip/g' docker-compose.yml
docker compose up -d
```

### 配置 Casdoor

1. 使用 `setup.sh` 脚本启动后，Casdoor WebUI 默认端口为 `8000`，你可以通过 `http://your_server_ip:8000` 访问，默认用户名 `admin`，密码 `123`

2. 在 `身份认证 -> 应用` 中添加一行

   ```
   http://your_server_ip:3210/api/auth/callback/casdoor
   ```

3. 其他配置大多保持默认即可，你也可以在 `身份认证 -> 应用` 中修改默认配置

### 配置 MinIO S3

1. 使用 `setup.sh` 脚本启动后，MinIO WebUI 默认端口为 `9001`，你可以通过 `http://your_server_ip:9001` 访问，默认用户名 `YOUR_MINIO_USER`，密码 `YOUR_MINIO_PASSWORD`

2. 大多数配置保持默认即可，如果你希望能允许用户更换头像功能，你需要首先在 `buckets` 中创建一个名为 `casdoor` 的桶，选择自定义策略，复制并粘贴如下内容（如果你修改了桶名，请自行查找替换）

   ```json
   {
     "Statement": [
       {
         "Effect": "Allow",
         "Principal": {
           "AWS": ["*"]
         },
         "Action": ["s3:GetBucketLocation"],
         "Resource": ["arn:aws:s3:::casdoor"]
       },
       {
         "Effect": "Allow",
         "Principal": {
           "AWS": ["*"]
         },
         "Action": ["s3:ListBucket"],
         "Resource": ["arn:aws:s3:::casdoor"],
         "Condition": {
           "StringEquals": {
             "s3:prefix": ["files/*"]
           }
         }
       },
       {
         "Effect": "Allow",
         "Principal": {
           "AWS": ["*"]
         },
         "Action": ["s3:PutObject", "s3:DeleteObject", "s3:GetObject"],
         "Resource": ["arn:aws:s3:::casdoor/**"]
       }
     ],
     "Version": "2012-10-17"
   }
   ```

3. 创建一个新的访问密钥，将生成的 `Access Key` 和 `Secret Key` 存储之

4. 在 Casdoor 的 `身份认证 -> 提供商` 中关联 MinIO S3 服务，以下是一个示例配置：

   ![casdoor](https://github.com/user-attachments/assets/71035610-0706-434e-9488-ab5819b55330)

   其中，客户端 ID、客户端密钥为上一步创建的访问密钥中的 `Access Key` 和 `Secret Key`，`192.168.31.251` 应当被替换为 `your_server_ip`。

5. 在 Casdoor 的 `身份认证 -> 应用` 中，对 `app-built-in` 应用添加提供商，选择 `minio`，保存并退出

6. 你可以在 Casdoor 的 `身份认证 -> 资源` 中，尝试上传文件以测试配置是否正确

## 发布到生产（域名模式）

### 基于 `Casdoor` 鉴权方法的生产部署

<Callout type="info">
  由于使用[Logto](https://logto.io/)
  作为登录鉴权服务存在比较大的不稳定性。
  因此，下文基于发布到IP模式的教程，实现了使用 Casdoor 作为鉴权服务提供商的域名发布方案。
  本文剩余部分也将以其为例进行说明。如果你使用其他诸如 Logto
  等其他登录鉴权服务，流程应当相近，但请注意不同的登录鉴权服务的端口配置可能有所差异。
</Callout>

在下文中，我们假设在上述服务之外，你还运行了一层 **Nginx** 来进行反向代理、配置 SSL。

域名和配套服务端口说明如下：

- `lobe.example.com`：为你的 LobeChat 服务端域名，需要反向代理到 LobeChat 服务端口，默认为 `3210`
- `auth-ui.example.com`：为你的 Logto UI 域名，需要反向代理到 Logto WebUI 服务端口，默认为 `8000`
- `s3-api.example.com`：为你的 MinIO API 域名，需要反向代理到 MinIO API 服务端口，默认为 `9000`
- `s3-ui.example.com`：可选，为你的 MinIO UI 域名，需要反向代理到 MinIO WebUI 服务端口，默认为 `9001`

#### 配置文件
```sh
bash <(curl -fsSL https://raw.githubusercontent.com/lobehub/lobe-chat/HEAD/docker-compose/local/setup.sh) -f -l zh_CN
docker compose up -d
```
注意保存此时生成的新密码！

运行后会获得三个文件
- init_data.json
- docker-compose.yml
- .env

接下来，修改配置文件以实现域名发布
1. 修改 `docker-compose.yml` 文件
    1. 修改 `minio`的`MINIO_API_CORS_ALLOW_ORIGIN`字段。
    ```yaml
          'MINIO_API_CORS_ALLOW_ORIGIN=https://lobe.example.com'
    ```
    2. 修改`casdoor`的`origin`字段。
    ```yaml
          origin: 'https://auth-ui.example.com'
    ```
    3. 修改`lobe`的`environment`字段。
    ```yaml
            # - 'APP_URL=http://localhost:3210'
      - 'APP_URL=https://lobe.example.com'

      - 'NEXT_AUTH_SSO_PROVIDERS=casdoor'
      - 'KEY_VAULTS_SECRET=Kix2wcUONd4CX51E/ZPAd36BqM4wzJgKjPtz2sGztqQ='
      - 'NEXT_AUTH_SECRET=NX2kaPE923dt6BL2U8e9oSre5RfoT7hg'
      # - 'AUTH_URL=http://localhost:${LOBE_PORT}/api/auth'
      - 'AUTH_URL=https://lobe.example.com/api/auth'

      # - 'AUTH_CASDOOR_ISSUER=http://localhost:${CASDOOR_PORT}'
      - 'AUTH_CASDOOR_ISSUER=https://auth-ui.example.com'

      - 'DATABASE_URL=postgresql://postgres:${POSTGRES_PASSWORD}@postgresql:5432/${LOBE_DB_NAME}'
      # - 'S3_ENDPOINT=http://localhost:${MINIO_PORT}'
      - 'S3_ENDPOINT=https://s3-api.example.com'

      - 'S3_BUCKET=${MINIO_LOBE_BUCKET}'
      # - 'S3_PUBLIC_DOMAIN=http://localhost:${MINIO_PORT}'
      - 'S3_PUBLIC_DOMAIN=https://s3-api.example.com'

      - 'S3_ENABLE_PATH_STYLE=1'
      - 'LLM_VISION_IMAGE_USE_BASE64=1'
    ```
2. 修改 `.env` 文件
<Callout type="info">
  为了安全起见，修改 `.env` 文件中的ROOT USER的字段
</Callout>
```sh
# MinIO S3 configuration
MINIO_ROOT_USER=XXXX
MINIO_ROOT_PASSWORD=XXXX
```

#### Postgres 数据库配置

你可以使用下述指令检查日志：

```sh
docker logs -f lobe-chat
```

<Callout type="tip">
  在我们官方的 Docker 镜像中，会在启动镜像前自动执行数据库 schema 的 migration
  ，我们的官方镜像承诺「空数据库 ->
  完整表」这一段自动建表的稳定性。因此我们建议你的数据库实例使用一个空表实例，进而省去手动维护表结构或者
  migration 的麻烦。
</Callout>

如果你在建表的时候出现了问题，你可以尝试使用如下命令强制移除数据库容器并重新启动：

```sh
docker compose down  # 停止服务
sudo rm -rf ./data   # 移除挂载的数据库数据
docker compose up -d # 重新启动
```


####  登录鉴权服务配置

你需要首先访问 WebUI 来进行配置：

- 如果你按照前文配置了反向代理，打开 `https://auth-ui.example.com`
- 否则，请在进行端口映射后，打开 `http://localhost:8000`

登录管理员账户

- 默认用户名为 admin
- 默认密码为 下载配置文件时生成的随机密码。如忘记可到 `init_data.json` 文件中找回

登入后执行如下操作
1. 在 `用户管理 -> 组织` 中，添加一个新的组织。名称与显示名称为 `Lobe Users`。其余保持默认即可。
2. 在 `身份认证 -> 应用` 中，添加一个新的应用。
  - 名称与显示名称为 `LobeChat`。
  - 组织为 `Lobe Users`。
  - 重定向 URLS中添加一行 为 `https://lobe.example.com/api/auth/callback/casdoor`。
  - 关闭除密码外的登录方式 。
  - 将客户端ID和客户端密钥分别填入 `.env`中的 `AUTH_CASDOOR_ID` 和 `AUTH_CASDOOR_SECRET` 中。
  - (可选) 仿照`built-in`应用的配置，来设计登录和注册的页面外观。
  - 保存并退出。

<Callout type="info">
  通过上述步骤，可以避免默认情况下所有用户均为管理员导致的不安全的情况。
</Callout>

#### S3 对象存储服务配置


本文以 MinIO 为例，解释配置过程，如果你使用的是其他 S3 服务商，请参照其文档进行配置。

<Callout type="warning">
  请记得注意配置对应 S3 服务商的 CORS 跨域配置，以确保 LobeChat 能够正常访问 S3 服务。

  在本文中，你需要允许 `https://lobe.example.com` 的跨域请求。这既可以在 MinIO WebUI 的 `Configuration - API - Cors Allow Origin` 中配置，也可以在 Docker Compose 中的 `minio - environment - MINIO_API_CORS_ALLOW_ORIGIN` 中配置。

  如果你使用第二种方法（这也是默认的方法）进行配置，你将无法再在 MinIO WebUI 中配置。
</Callout>

你需要首先访问 WebUI 来进行配置：

- 如果你按照前文配置了反向代理，打开 `https://s3-ui.example.com`
- 否则，请在进行端口映射后，打开 `http://localhost:9001`

1. 在登录界面输入你设置的 `MINIO_ROOT_USER` 和 `MINIO_ROOT_PASSWORD`，然后点击登录

2. 在左侧面板 User / Access Keys 处，点击 `Create New Access Key`，无需额外修改，将生成的 `Access Key` 和 `Secret Key` 填入你的 `.env` 文件中的 `S3_ACCESS_KEY_ID` 和 `S3_SECRET_ACCESS_KEY` 中

   <Image alt="创建 MinIO 访问密钥" src="https://github.com/user-attachments/assets/72f02ce5-9991-425b-9864-9113ee1ed6bf" />

3. 重启 LobeChat 服务：

   ```sh
   docker compose up -d
   ```

至此，你已经成功部署了 LobeChat 数据库版本，你可以通过 `https://lobe.example.com` 访问你的 LobeChat 服务。



## 附录

为方便一键复制，在此汇总基于casdoor鉴权方案的域名方式下生产部署配置服务端数据库所需要的示例配置文件。

### `.env` 

```sh
# Proxy, if you need it
# HTTP_PROXY=http://localhost:7890
# HTTPS_PROXY=http://localhost:7890


# Other environment variables, as needed. You can refer to the environment variables configuration for the client version, making sure not to have ACCESS_CODE.
# OPENAI_API_KEY=sk-xxxx
# OPENAI_PROXY_URL=https://api.openai.com/v1
# OPENAI_MODEL_LIST=...


# ===========================
# ====== Preset config ====== 
# ===========================
# if no special requirements, no need to change
LOBE_PORT=3210
CASDOOR_PORT=8000
MINIO_PORT=9000

# Postgres related, which are the necessary environment variables for DB
LOBE_DB_NAME=lobechat
POSTGRES_PASSWORD=uWNZugjBqixf8dxC

# Casdoor secret
AUTH_CASDOOR_ID=943e627d79d5dd8a22a1
AUTH_CASDOOR_SECRET=6ec24ac304e92e160ef0d0656ecd86de8cb563f1

# MinIO S3 configuration
MINIO_ROOT_USER=Joe
MINIO_ROOT_PASSWORD=Crj1570768

# Configure the bucket information of MinIO
MINIO_LOBE_BUCKET=lobe
S3_ACCESS_KEY_ID=dB6Uq9CYZPdWSZouPyEd
S3_SECRET_ACCESS_KEY=aPBW8CVULkh8bw1GatlT0GjLihcXHLNwRml4pieS

```

### `docker-compose.yml`

```yaml
name: lobe-chat-database
services:
  network-service:
    image: alpine
    container_name: lobe-network
    ports:
      - '${MINIO_PORT}:${MINIO_PORT}' # MinIO API
      - '9001:9001' # MinIO Console
      - '${CASDOOR_PORT}:${CASDOOR_PORT}' # Casdoor
      - '${LOBE_PORT}:3210' # LobeChat
    command: tail -f /dev/null
    networks:
      - lobe-network

  postgresql:
    image: pgvector/pgvector:pg16
    container_name: lobe-postgres
    ports:
      - '5432:5432'
    volumes:
      - './data:/var/lib/postgresql/data'
    environment:
      - 'POSTGRES_DB=${LOBE_DB_NAME}'
      - 'POSTGRES_PASSWORD=${POSTGRES_PASSWORD}'
    healthcheck:
      test: ['CMD-SHELL', 'pg_isready -U postgres']
      interval: 5s
      timeout: 5s
      retries: 5
    restart: always
    networks:
      - lobe-network

  minio:
    image: minio/minio
    container_name: lobe-minio
    network_mode: 'service:network-service'
    volumes:
      - './s3_data:/etc/minio/data'
    environment:
      - 'MINIO_ROOT_USER=${MINIO_ROOT_USER}'
      - 'MINIO_ROOT_PASSWORD=${MINIO_ROOT_PASSWORD}'
      # - 'MINIO_API_CORS_ALLOW_ORIGIN=http://localhost:${LOBE_PORT}'
      - 'MINIO_API_CORS_ALLOW_ORIGIN=https://lobe.example.com'
    restart: always
    command: >
      server /etc/minio/data --address ":${MINIO_PORT}" --console-address ":9001"


  casdoor:
    image: casbin/casdoor
    container_name: lobe-casdoor
    entrypoint: /bin/sh -c './server --createDatabase=true'
    network_mode: 'service:network-service'
    depends_on:
      postgresql:
        condition: service_healthy
    environment:
      RUNNING_IN_DOCKER: 'true'
      driverName: 'postgres'
      dataSourceName: 'user=postgres password=${POSTGRES_PASSWORD} host=postgresql port=5432 sslmode=disable dbname=casdoor'
      # origin: 'http://localhost:${CASDOOR_PORT}'
      origin: 'https://auth-ui.example.com'
      runmode: 'dev'
    volumes:
      - ./init_data.json:/init_data.json

  lobe:
    image: lobehub/lobe-chat-database
    container_name: lobe-chat-database
    network_mode: 'service:network-service'
    depends_on:
      postgresql:
        condition: service_healthy
      network-service:
        condition: service_started
      minio:
        condition: service_started
      casdoor:
        condition: service_started

    environment:
      # - 'APP_URL=http://localhost:3210'
      - 'APP_URL=https://lobe.example.com'

      - 'NEXT_AUTH_SSO_PROVIDERS=casdoor'
      - 'KEY_VAULTS_SECRET=Kix2wcUONd4CX51E/ZPAd36BqM4wzJgKjPtz2sGztqQ='
      - 'NEXT_AUTH_SECRET=NX2kaPE923dt6BL2U8e9oSre5RfoT7hg'
      # - 'AUTH_URL=http://localhost:${LOBE_PORT}/api/auth'
      - 'AUTH_URL=https://lobe.example.com/api/auth'

      # - 'AUTH_CASDOOR_ISSUER=http://localhost:${CASDOOR_PORT}'
      - 'AUTH_CASDOOR_ISSUER=https://auth-ui.example.com'

      - 'DATABASE_URL=postgresql://postgres:${POSTGRES_PASSWORD}@postgresql:5432/${LOBE_DB_NAME}'
      # - 'S3_ENDPOINT=http://localhost:${MINIO_PORT}'
      - 'S3_ENDPOINT=https://s3-api.example.com'

      - 'S3_BUCKET=${MINIO_LOBE_BUCKET}'
      # - 'S3_PUBLIC_DOMAIN=http://localhost:${MINIO_PORT}'
      - 'S3_PUBLIC_DOMAIN=https://s3-api.example.com'

      - 'S3_ENABLE_PATH_STYLE=1'
      - 'LLM_VISION_IMAGE_USE_BASE64=1'
    env_file:
      - .env
    restart: always

volumes:
  data:
    driver: local
  s3_data:
    driver: local

networks:
  lobe-network:
    driver: bridge


```


[docker-pulls-link]: https://hub.docker.com/r/lobehub/lobe-chat-database
[docker-pulls-shield]: https://img.shields.io/docker/pulls/lobehub/lobe-chat-database?color=45cc11&labelColor=black&style=flat-square
[docker-release-link]: https://hub.docker.com/r/lobehub/lobe-chat-database
[docker-release-shield]: https://img.shields.io/docker/v/lobehub/lobe-chat-database?color=369eff&label=docker&labelColor=black&logo=docker&logoColor=white&style=flat-square
[docker-size-link]: https://hub.docker.com/r/lobehub/lobe-chat-database
[docker-size-shield]: https://img.shields.io/docker/image-size/lobehub/lobe-chat-database?color=369eff&labelColor=black&style=flat-square