Docker on Linkzz's Blog

内网自部署存储迁移到自部署的 S3

Sat, 02 May 2026 00:00:00 +0000

内网自部署存储迁移到自部署的 S3

1. 存储的烦恼

我日常会使用一些自部署的服务，如写作的 Affine、代码服务 Gitea、备忘录记录服务 memos 记录自己的碎碎念。自部署这些服务的时候通常会涉及一些资源的存储，比如 Affine 中上传的图片资源、Gitea 的 package 制品、memos 中上传的图片等都需要消耗自身的存储空间。而我部署的平台是 PVE 的 Docker LXD 容器，这个容器里面使用 Docker 部署了一堆服务，存储已经扩了一遍又一遍了，然而主机上的存储也见底了。

正好家里还有一台绿联的 NAS，里面有一个闲置的存储池，正好用来建一个 S3 存储给以上这些服务使用。这样一方面可以在同一个地方管理上传的对象，另一方面也可以利用存储池 Raid 做一些备份。

2. 部署 Rustfs

要说开源 S3 实现就不得不提大名鼎鼎的 Minio 了，然而其因为商业化已经停止了仓库的维护。况且我的 NAS 也仅是 4C8G 的配置，所以资源能省则省，基于 Rust 开发的 Rustfs 就是最好的选择——部署简单，资源占用低，性能还高，简直是居家旅行、自部署常备。

NAS 上的 Docker 不能命令行，只能图形界面操作，就略过部署过程了。

部署好了之后打开 console 端口 9001 即可进行存储桶操作。

2.1 使用 AWS CLI 测试访问

创建一个访问密钥，使用 AWS CLI 来测试访问。在 ~/.aws/credentials 中配置好访问密钥，~/.aws/config 中配置 endpoint 信息：

[default]
region=us-east-1
endpoint_url=http://192.168.5.103:9000

region 随便填一个值就可，测试访问：

➜ : aws s3 ls s3://
2026-04-22 00:58:25 affine-storage
2026-04-22 15:20:44 gitea-storage
2026-04-22 00:42:14 linkzz-bucket

3. 使用 Rustfs 存储数据

下面介绍使用 Rustfs 储存的服务。

3.1 Affine

内网 Affine 的搭建可以看这篇文章。Affine 的存储引擎默认是本地文件系统，在 admin 页面可以更换为 S3 存储。

可以分两个存储桶，一个存上传的媒体文件，一个存用户头像。内网使用用户就一个，单独建一个桶来存媒体文件就好了。

文件已然美美的上传了。

3.2 Gitea

Gitea 的代码不支持 S3 存储，但好在自己写的代码也不会太占空间。但是如果用到 Gitea 的 Package 上传一些 Docker 镜像或者是存储流水线存储的制品，这些可是很占空间的。好在这些都是支持 S3 存储的。这里要赞扬一波 Gitea，公司内部的代码库也是我搭的 Gitea，虽然脱胎于 Gogs，但在保持 Gogs 轻量级体验的同时引入了很多 GitHub 相关的功能，如完全兼容 GitHub Actions 的流水线、同样的 Package 系统（支持 Docker 镜像、Java Nexus Maven 仓库、NPM Registry 等），常见的语言依赖仓库都支持，省了很多自建的烦恼，使用起来也是极其丝滑。一个开源的产品能做到这样真的没得说。

Gitea 需要在配置文件中开启 S3 存储，加入下面的配置项重启即可：

[storage]
STORAGE_TYPE = minio
MINIO_ENDPOINT = 192.168.5.103:9000
MINIO_ACCESS_KEY_ID = YOUR_AK
MINIO_SECRET_ACCESS_KEY = YOUR_SK
MINIO_BUCKET = gitea-storage
MINIO_LOCATION = us-east-1

构建一个 Docker 镜像上传试试看：

gitea-storage 桶里面也有值了，只是为啥这么小，压缩率这么大的吗？后续再研究一下。

3.3 Memos

Memos 也是原生支持 S3 存储，后台配置一下即可：

测试一下：

看下桶里面有没有数据：

没问题！搞定！

4. 总结

终于是将一些自部署服务的媒体文件都搜集起来了。使用 S3 来集中存储自部署的这些文件，以后部署在甲骨文上的一些服务也可以将存储迁移到 S3 桶里面。后续再做一个定期将服务数据打包上传 S3，再也不怕哪天甲骨文突然被收回了。

自签名证书部署内网 https 版 lobe-chat

Fri, 07 Feb 2025 00:00:00 +0000

1. 背景

一开始部署了 Nextchat 作为我日常的 AI 问答网页应用，原因很简单：

该项目启动早，社区很活跃
网页应用结合 PWA 使用起来也很方便
支持模型供应商全面

但是使用了一段时间之后接触到了更为全面和强大的 lobe-chat，lobe-chat 发展迅速，社区更为活跃，社区版支持子部署，且没有功能限制，公司级的开源项目，产品 UI 设计很现代，社区 Roadmap 还计划支持更多的功能，如文生视频，助手自主学习等功能（无恰饭，纯使用感受）。

起初仅通过 docker-compose 部署了纯前端版本的 lobe-chat，这个版本由于是纯前端，没有多端同步的功能，同一份配置需要在家里电脑、公司电脑和手机上重复配置，相当麻烦，所以还是部署数据库版本的完全体 lobe-chat 更为合适。

2. 官方脚本部署

2.1 脚本部署

说干就干，目前版本是 v1.49.12，使用官方 docker-compose 部署脚本部署：

bash <(curl -fsSL https://lobe.li/setup.sh) -l zh_CN

支持 3 种模式部署：

本地模式（默认）：仅能在本地访问，不支持局域网 / 公网访问，适用于初次体验；
端口模式：支持局域网 / 公网的 http 访问，适用于无域名或内部办公场景使用；
域名模式：支持局域网 / 公网在使用反向代理下的 http/https 访问，适用于个人或团队日常使用；

第一种模式纯自身访问，无法从其他设备访问，局限性很大；第二种模式在局域网中访问可行，但是 IP 端口访问的方式在局域网环境中我并不推崇，一是需要记忆特定的 IP 端口，而是 http 的方式无法安装 PWA 应用，仅适用于初次体验，而我自身用于家庭服务器，并且部署了一个自签名证书的 Nginx，完全可以试用该证书部署 https 的服务，而不用担心暴露公网，通过 VPN 即可在任何地方访问家庭服务也很方便，关于自签名证书和我的服务器拓扑 VPN 配置等信息我在这篇文章以及这篇文章中有详细介绍，这里不再赘述。

先规划 4 个域名作为服务：

域名	描述	代理端口
lobe.linkzz.hm	lobe chat 主域名	3210
lobe-login.linkzz.hm	lobe chat oauth提供商casdoor管理地址，登录/注册地址	8000
lobe-mc.linkzz.hm	lobe chat S3服务，minio api 访问地址	9000
lobe-mc-ui.linkzz.hm	minio s3 console ui 访问地址	9001

以上在官方脚本部署的时候输入相应的域名即可，其他的密码等按照提示输入修改，之后脚本会修改 .env 、docker-compose.yml 、init_data.json 3 个配置文件，确认无误之后执行 docker compose up -d 启动服务

2.2 排查问题

执行 docker compose ps 查看服务状态，发现所有服务均处于正常 RUNNING 状态

但是执行 docker compose logs -f 发现 minio 服务一直在报错

lobe-minio     | /bin/sh: line 4: curl: command not found
lobe-minio     | Waiting for MinIO to start…

查看 docker-compose.yml 文件

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_API_CORS_ALLOW_ORIGIN=*'
    env_file:
      - .env
    restart: always
    entrypoint: >
      /bin/sh -c "
        minio server /etc/minio/data --address ':${MINIO_PORT}' --console-address ':9001' &
        MINIO_PID=\$!
        while ! curl -s http://localhost:${MINIO_PORT}/minio/health/live; do
          echo 'Waiting for MinIO to start...'
          sleep 1
        done
        sleep 5
        mc alias set myminio http://localhost:${MINIO_PORT} ${MINIO_ROOT_USER} ${MINIO_ROOT_PASSWORD}
        echo 'Creating bucket ${MINIO_LOBE_BUCKET}'
        mc mb myminio/${MINIO_LOBE_BUCKET}
        wait \$MINIO_PID
      "      

  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'
      runmode: 'dev'
    volumes:
      - ./init_data.json:/init_data.json
    env_file:
      - .env

  lobe:
    image: lobehub/lobe-chat-database
    container_name: lobe-chat
    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:
      - 'NEXT_AUTH_SSO_PROVIDERS=casdoor'
      - 'KEY_VAULTS_SECRET=Kix2wcUONd4CX51E/ZPAd36BqM4wzJgKjPtz2sGztqQ='
      - 'NEXT_AUTH_SECRET=NX2kaPE923dt6BL2U8e9oSre5RfoT7hg'
      - 'DATABASE_URL=postgresql://postgres:${POSTGRES_PASSWORD}@postgresql:5432/${LOBE_DB_NAME}'
      - 'S3_BUCKET=${MINIO_LOBE_BUCKET}'
      - 'S3_ENABLE_PATH_STYLE=1'
      - 'S3_ACCESS_KEY=${MINIO_ROOT_USER}'
      - 'S3_ACCESS_KEY_ID=${MINIO_ROOT_USER}'
      - 'S3_SECRET_ACCESS_KEY=${MINIO_ROOT_PASSWORD}'
      - 'LLM_VISION_IMAGE_USE_BASE64=1'
    env_file:
      - .env
    restart: always

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

networks:
  lobe-network:
    driver: bridge

发现 minio 的服务中会重复检查 minio 的服务正常启动之后再执行创建桶的操作，但是容器确实 curl 工具导致服务桶服务创建，但是容器并没有退出，这样即使 lobe-chat 的服务能正常运行后面涉及到存储操作的时候也一定会出现问题，这就来解决一下这个问题。

minio 服务是基于 minio/minio:latest 镜像，通过 docker hub 可以查看该版本的镜像 layer，在 docker hub 中搜索 minio/minio:latest ，在 tags 中筛选出对应标签即可看到各个架构镜像的 hash, 点击 hash 即可跳转镜像层浏览页，我这里使用的 linux/amd64 架构的镜像。

`1``LABEL maintainer="Red Hat, Inc."``0 B`

`2``LABEL vendor="Red Hat, Inc."``0 B`

`3``LABEL url="https://www.redhat.com"``0 B`

`4``LABEL com.redhat.component="ubi9-micro-container"``0 B`

`5``LABEL name="ubi9/ubi-micro"``0 B`

`6``LABEL version="9.5"``0 B`

`7``LABEL distribution-scope="public"``0 B`

`8``LABEL com.redhat.license_terms="https://www.redhat.com/en/about/red-hat-end-user-license-agreements#UBI"``0 B`

`9``LABEL summary="ubi9 micro image"``0 B`

`10``LABEL description="Very small image which``0 B`

`11``LABEL io.k8s.description="Very small image which``0 B`

`12``LABEL io.k8s.display-name="Red Hat Universal Base``0 B`

`13``LABEL io.openshift.expose-services=""``0 B`

`14``COPY dir:f89de9a231f3a4edbee769aa68d7a28b19bf78f5d7243315a0df3b339f370b11 in /``0 B`

`15``COPY file:b37d593713ee21ad52a4cd1424dc019a24f7966f85df0ac4b86d234302695328 in /etc/yum.repos.d/``0 B`

`16``CMD /bin/sh``0 B`

`17``LABEL "build-date"="2025-01-09T12:48:29" "architecture"="x86_64" "vcs-type"="git" "vcs-ref"="0bf50525dc8ce0b1f0fb83b0d10a826d8c769a89"``6.92 MB`

`18``/bin/sh``389 B`

`19``ARG RELEASE=RELEASE.2025-02-03T21-03-04Z``0 B`

`20``LABEL name=MinIO vendor=MinIO Inc <dev@min.io>``0 B`

`21``ENV MINIO_ACCESS_KEY_FILE=access_key MINIO_SECRET_KEY_FILE=secret_key MINIO_ROOT_USER_FILE=access_key MINIO_ROOT_PASSWORD_FILE=secret_key``0 B`

`22``RUN |1 RELEASE=RELEASE.2025-02-03T21-03-04Z /bin/sh -c``1.56 MB`

`23``COPY /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ # buildkit``125.3 KB`

`24``COPY /go/bin/minio* /usr/bin/ # buildkit``38.92 MB`

`25``COPY /go/bin/mc* /usr/bin/ # buildkit``10.23 MB`

`26``COPY /go/bin/curl* /usr/bin/ # buildkit``2.29 MB`

`27``COPY CREDITS /licenses/CREDITS # buildkit``169.36 KB`

`28``COPY LICENSE /licenses/LICENSE # buildkit``11.6 KB`

`29``COPY dockerscripts/docker-entrypoint.sh /usr/bin/docker-entrypoint.sh # buildkit``500 B`

`30``EXPOSE map[9000/tcp:{}]``0 B`

`31``VOLUME [/data]``0 B`

`32``ENTRYPOINT ["/usr/bin/docker-entrypoint.sh"]``0 B`

`33``CMD ["minio"]``0 B`

可是看到该镜像层中明明有 COPY /go/bin/curl* /usr/bin 的操作，却在镜像中无法找到该命令，这不应该呀，仔细排查一通才发现，我本地的镜像根本没更新到，原因是官方的脚本在最后部署的时候只说了运行 docker compose up -d 而没有更新进行，恰好我的原来已然下载了 minio 的 latest 标签镜像，这才在 docker compose up 的时候没有去更新该镜像，再来看下本地镜像的镜像层信息，运行 docker history minio/minio:latest 如下：

root@Docker ~/apps/lobe-chat$ docker history minio/minio:latest --no-trunc
IMAGE                                                                     CREATED         CREATED BY                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SIZE      COMMENT
sha256:57f1cc3888f19d7d4480f3a6539d20992e18c5aeeaebced1518bd07c84379e11   12 months ago   CMD ["minio"]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 0B        buildkit.dockerfile.v0
<missing>                                                                 12 months ago   ENTRYPOINT ["/usr/bin/docker-entrypoint.sh"]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  0B        buildkit.dockerfile.v0
<missing>                                                                 12 months ago   VOLUME [/data]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                0B        buildkit.dockerfile.v0
<missing>                                                                 12 months ago   EXPOSE map[9000/tcp:{}]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       0B        buildkit.dockerfile.v0
<missing>                                                                 12 months ago   COPY dockerscripts/docker-entrypoint.sh /usr/bin/docker-entrypoint.sh # buildkit                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              675B      buildkit.dockerfile.v0
<missing>                                                                 12 months ago   COPY LICENSE /licenses/LICENSE # buildkit                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     34.5kB    buildkit.dockerfile.v0
<missing>                                                                 12 months ago   COPY CREDITS /licenses/CREDITS # buildkit                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     1.77MB    buildkit.dockerfile.v0
<missing>                                                                 12 months ago   COPY /go/bin/mc /usr/bin/mc # buildkit                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        26.9MB    buildkit.dockerfile.v0
<missing>                                                                 12 months ago   COPY /go/bin/minio /usr/bin/minio # buildkit                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  99.9MB    buildkit.dockerfile.v0
<missing>                                                                 12 months ago   COPY /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ # buildkit                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            215kB     buildkit.dockerfile.v0
<missing>                                                                 12 months ago   ENV MINIO_ACCESS_KEY_FILE=access_key MINIO_SECRET_KEY_FILE=secret_key MINIO_ROOT_USER_FILE=access_key MINIO_ROOT_PASSWORD_FILE=secret_key MINIO_KMS_SECRET_KEY_FILE=kms_master_key MINIO_UPDATE_MINISIGN_PUBKEY=RWTx5Zr1tiHQLwG9keckT0c45M3AGeHD6IvimQHpyRywVWGbP1aVSGav MINIO_CONFIG_ENV_FILE=config.env MC_CONFIG_DIR=/tmp/.mc                                                                                                                                                                                                                                              0B        buildkit.dockerfile.v0
<missing>                                                                 12 months ago   LABEL name=MinIO vendor=MinIO Inc <dev@min.io> maintainer=MinIO Inc <dev@min.io> version=RELEASE.2024-02-04T22-36-13Z release=RELEASE.2024-02-04T22-36-13Z summary=MinIO is a High Performance Object Storage, API compatible with Amazon S3 cloud storage service. description=MinIO object storage is fundamentally different. Designed for performance and the S3 API, it is 100% open-source. MinIO is ideal for large, private cloud environments with stringent security requirements and delivers mission-critical availability across a diverse range of workloads.   0B        buildkit.dockerfile.v0
<missing>                                                                 12 months ago   ARG RELEASE                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   0B        buildkit.dockerfile.v0
<missing>                                                                 12 months ago   /bin/sh -c #(nop) LABEL "distribution-scope"="public" "vendor"="Red Hat, Inc." "build-date"="2024-01-18T10:06:04" "architecture"="x86_64" "vcs-type"="git" "vcs-ref"="303dc144996db01765d69e8ea45d2d617d953e42" "io.k8s.description"="Very small image which doesn't install the package manager." "url"="https://access.redhat.com/containers/#/registry.access.redhat.com/ubi9/ubi-micro/images/9.3-13"                                                                                                                                                                     22.7MB
<missing>                                                                 12 months ago   /bin/sh -c #(nop) ADD file:0fc7de14fc44e1d80c5ac6d6062ee58a9464555c26081dbb7050df8f2a8e586d in /root/buildinfo/Dockerfile-ubi9-ubi-micro-9.3-13                                                                                                                                                                                                                                                                                                                                                                                                                               0B
<missing>                                                                 12 months ago   /bin/sh -c #(nop) ADD file:6dca2b6931e721dc2515dbd66acd41501bf4bbd06ad9c6d0d5950a8f4af77a5d in /root/buildinfo/content_manifests/ubi9-micro-container-9.3-13.json                                                                                                                                                                                                                                                                                                                                                                                                             0B
<missing>                                                                 12 months ago   /bin/sh -c #(nop) LABEL release=13                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            0B
<missing>                                                                 12 months ago   /bin/sh -c #(nop) CMD /bin/sh                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 0B
<missing>                                                                 12 months ago   /bin/sh -c #(nop) COPY file:eec73f859c6e7f6c8a9427ecc5249504fe89ae54dc3a1521b442674a90497d32 in /etc/yum.repos.d/ubi.repo                                                                                                                                                                                                                                                                                                                                                                                                                                                     0B
<missing>                                                                 12 months ago   /bin/sh -c #(nop) COPY dir:b4c56c8ee136a3d8550817bb736bcd586be7da120fa51e85d80783b087276962 in /                                                                                                                                                                                                                                                                                                                                                                                                                                                                              0B
<missing>                                                                 12 months ago   /bin/sh -c #(nop) LABEL io.openshift.expose-services=""                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       0B
<missing>                                                                 12 months ago   /bin/sh -c #(nop) LABEL io.k8s.display-name="Ubi9-micro"                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      0B
<missing>                                                                 12 months ago   /bin/sh -c #(nop) LABEL description="Very small image which doesn't install the package manager."                                                                                                                                                                                                                                                                                                                                                                                                                                                                             0B
<missing>                                                                 12 months ago   /bin/sh -c #(nop) LABEL summary="ubi9 micro image"                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            0B
<missing>                                                                 12 months ago   /bin/sh -c #(nop) LABEL com.redhat.license_terms="https://www.redhat.com/en/about/red-hat-end-user-license-agreements#UBI"                                                                                                                                                                                                                                                                                                                                                                                                                                                    0B
<missing>                                                                 12 months ago   /bin/sh -c #(nop) LABEL version="9.3"                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         0B
<missing>                                                                 12 months ago   /bin/sh -c #(nop) LABEL name="ubi9/ubi-micro"                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 0B
<missing>                                                                 12 months ago   /bin/sh -c #(nop) LABEL com.redhat.component="ubi9-micro-container"                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           0B
<missing>                                                                 12 months ago   /bin/sh -c #(nop) LABEL maintainer="Red Hat, Inc."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            0B

果然这个版本中并没有静态的 curl 工具，基础镜像中也没有自带 curl，这才导致了 curl 命令找不到的问题

知道了原因解决就简单多了，执行 docker compose pull 更新一下镜像，之后再执行 docker compose up -d 运行服务就好了

3. 自签名证书的问题

按照上面的域名配置好端口转发之后访问 https://lobe.linkzz.hm 首页跳转登录的时候报错了

https://lobe.linkzz.hm/next-auth/error?error=Configuration

查看后台日志报错如下：

lobe-chat      | [auth][error] TypeError: fetch failed
lobe-chat      |     at node:internal/deps/undici/undici:13502:13
lobe-chat      |     at process.processTicksAndRejections (node:internal/process/task_queues:105:5)
lobe-chat      |     at async iY (/app/.next/server/chunks/1774.js:368:46924)
lobe-chat      |     at async iQ (/app/.next/server/chunks/1774.js:368:49798)
lobe-chat      |     at async i5 (/app/.next/server/chunks/1774.js:368:52440)
lobe-chat      |     at async i6 (/app/.next/server/chunks/1774.js:368:56596)
lobe-chat      |     at async tr.do (/app/node_modules/.pnpm/next@15.1.6_@babel+core@7.26.7_@opentelemetry+api@1.9.0_@playwright+test@1.50.1_react-dom@19._snrbxk6bhvu4ah46wgxzyq2vee/node_modules/next/dist/compiled/next-server/app-route.runtime.prod.js:18:17582)
lobe-chat      |     at async tr.handle (/app/node_modules/.pnpm/next@15.1.6_@babel+core@7.26.7_@opentelemetry+api@1.9.0_@playwright+test@1.50.1_react-dom@19._snrbxk6bhvu4ah46wgxzyq2vee/node_modules/next/dist/compiled/next-server/app-route.runtime.prod.js:18:22212)
lobe-chat      |     at async doRender (/app/node_modules/.pnpm/next@15.1.6_@babel+core@7.26.7_@opentelemetry+api@1.9.0_@playwright+test@1.50.1_react-dom@19._snrbxk6bhvu4ah46wgxzyq2vee/node_modules/next/dist/server/base-server.js:1452:42)
lobe-chat      |     at async responseGenerator (/app/node_modules/.pnpm/next@15.1.6_@babel+core@7.26.7_@opentelemetry+api@1.9.0_@playwright+test@1.50.1_react-dom@19._snrbxk6bhvu4ah46wgxzyq2vee/node_modules/next/dist/server/base-server.js:1822:28)
lobe-chat      | [NextAuth] Error: {
lobe-chat      |   cause: 'Configuration',
lobe-chat      |   message: 'Wrong configuration, make sure you have the correct environment variables set. Visit https://lobehub.com/docs/self-hosting/advanced/authentication for more details.',
lobe-chat      |   name: 'NextAuth Error'
lobe-chat      | }

同样排查了一番之后才发现因为是自签名的 ssl 证书，在容器中访问的时候并没有加载宿主机的证书，导致 lobe-chat 服务访问 lobe-casdoor 容器的时候证书错误。

这里有两个解决方案：

3.1 忽略证书错误

由于 lobe-chat 是一个 nodejs 程序，我们在 nodejs 的配置中配置忽略证书错误即可正常访问 casdoor 和 minio 的 api，配置如下: 编辑 .env 文件，添加一行环境变量：

NODE_TLS_REJECT_UNAUTHORIZED=0

之后重新创建容器：

docker compose down && docker compose up -d

3.2 挂载宿主机证书目录

第二种方法前面文章提到过，在信任了该证书的宿主机上可以挂载宿主机的证书目录到容器中，这样容器也可正常访问其他两个服务。

修改 docker-compose.yml 文件 diff：

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

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

  minio:                                                          minio:
    image: minio/minio                                              image: minio/minio
    container_name: lobe-minio                                      container_name: lobe-minio
    network_mode: 'service:network-service'                         network_mode: 'service:network-service'
    volumes:                                                        volumes:
      - './s3_data:/etc/minio/data'                                   - './s3_data:/etc/minio/data'
    environment:                                                    environment:
      - 'MINIO_API_CORS_ALLOW_ORIGIN=*'                               - 'MINIO_API_CORS_ALLOW_ORIGIN=*'
    env_file:                                                       env_file:
      - .env                                                          - .env
    restart: always                                                 restart: always
    entrypoint: >                                                   entrypoint: >
      /bin/sh -c "                                                    /bin/sh -c "
        minio server /etc/minio/data --address ':${MINIO_PORT           minio server /etc/minio/data --address ':${MINIO_PORT
        MINIO_PID=\$!                                                   MINIO_PID=\$!
        while ! curl -s http://localhost:${MINIO_PORT}/minio/           while ! curl -s http://localhost:${MINIO_PORT}/minio/
          echo 'Waiting for MinIO to start...'                            echo 'Waiting for MinIO to start...'
          sleep 1                                                         sleep 1
        done                                                            done
        sleep 5                                                         sleep 5
        mc alias set myminio http://localhost:${MINIO_PORT} $           mc alias set myminio http://localhost:${MINIO_PORT} $
        echo 'Creating bucket ${MINIO_LOBE_BUCKET}'                     echo 'Creating bucket ${MINIO_LOBE_BUCKET}'
        mc mb myminio/${MINIO_LOBE_BUCKET}                              mc mb myminio/${MINIO_LOBE_BUCKET}
        wait \$MINIO_PID                                                wait \$MINIO_PID
      "                                                               "      

  casdoor:                                                        casdoor:
    image: casbin/casdoor                                           image: casbin/casdoor
    container_name: lobe-casdoor                                    container_name: lobe-casdoor
    entrypoint: /bin/sh -c './server --createDatabase=true'         entrypoint: /bin/sh -c './server --createDatabase=true'
    network_mode: 'service:network-service'                         network_mode: 'service:network-service'
    depends_on:                                                     depends_on:
      postgresql:                                                     postgresql:
        condition: service_healthy                                      condition: service_healthy
    environment:                                                    environment:
      RUNNING_IN_DOCKER: 'true'                                       RUNNING_IN_DOCKER: 'true'
      driverName: 'postgres'                                          driverName: 'postgres'
      dataSourceName: 'user=postgres password=${POSTGRES_PASS         dataSourceName: 'user=postgres password=${POSTGRES_PASS
      runmode: 'dev'                                                  runmode: 'dev'
    volumes:                                                        volumes:
      - ./init_data.json:/init_data.json                              - ./init_data.json:/init_data.json
    env_file:                                                       env_file:
      - .env                                                          - .env

  lobe:                                                           lobe:
    image: lobehub/lobe-chat-database                               image: lobehub/lobe-chat-database
    container_name: lobe-chat                                       container_name: lobe-chat
    network_mode: 'service:network-service'                         network_mode: 'service:network-service'
    depends_on:                                                     depends_on:
      postgresql:                                                     postgresql:
        condition: service_healthy                                      condition: service_healthy
      network-service:                                                network-service:
        condition: service_started                                      condition: service_started
      minio:                                                          minio:
        condition: service_started                                      condition: service_started
      casdoor:                                                        casdoor:
        condition: service_started                                      condition: service_started
    volumes:                                                  <
      - /etc/ssl/certs:/etc/ssl/certs:ro                      <

    environment:                                                    environment:
      - 'NEXT_AUTH_SSO_PROVIDERS=casdoor'                             - 'NEXT_AUTH_SSO_PROVIDERS=casdoor'
      - 'KEY_VAULTS_SECRET=Kix2wcUONd4CX51E/ZPAd36BqM4wzJgKjP         - 'KEY_VAULTS_SECRET=Kix2wcUONd4CX51E/ZPAd36BqM4wzJgKjP
      - 'NEXT_AUTH_SECRET=NX2kaPE923dt6BL2U8e9oSre5RfoT7hg'           - 'NEXT_AUTH_SECRET=NX2kaPE923dt6BL2U8e9oSre5RfoT7hg'
      - 'DATABASE_URL=postgresql://postgres:${POSTGRES_PASSWO         - 'DATABASE_URL=postgresql://postgres:${POSTGRES_PASSWO
      - 'S3_BUCKET=${MINIO_LOBE_BUCKET}'                              - 'S3_BUCKET=${MINIO_LOBE_BUCKET}'
      - 'S3_ENABLE_PATH_STYLE=1'                                      - 'S3_ENABLE_PATH_STYLE=1'
      - 'S3_ACCESS_KEY=${MINIO_ROOT_USER}'                            - 'S3_ACCESS_KEY=${MINIO_ROOT_USER}'
      - 'S3_ACCESS_KEY_ID=${MINIO_ROOT_USER}'                         - 'S3_ACCESS_KEY_ID=${MINIO_ROOT_USER}'
      - 'S3_SECRET_ACCESS_KEY=${MINIO_ROOT_PASSWORD}'                 - 'S3_SECRET_ACCESS_KEY=${MINIO_ROOT_PASSWORD}'
      - 'LLM_VISION_IMAGE_USE_BASE64=1'                               - 'LLM_VISION_IMAGE_USE_BASE64=1'
    env_file:                                                       env_file:
      - .env                                                          - .env
    restart: always                                                 restart: always

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

networks:                                                       networks:
  lobe-network:                                                   lobe-network:
    driver: bridge                                                  driver: bridge

4. 结语

私有的 AI 助手一直是我的刚需，知识库功能也比较吸引人，接下来我会将我的文档导入其中来构造私有的个人 RAG 助手，以便以后总结使用。

简单记录一下 Docker 容器中信任一个自签名证书的案例

Wed, 10 Apr 2024 00:00:00 +0000

1. 背景

起因是我的 ttrss 容器需要订阅一个自部署的微信公众号订阅服务 wewe-rss ，在 web 页面添加订阅一个订阅源 http://192.168.5.128:8109/feeds/MP_WXS_3925660753.atom，添加之后 ttrss 报错

无法从指定的网址下载:cURL error 7: Failed to connect to 192.168.5.128 port 80 after 0 ms: Couldn't connect to server (see https://curl.haxx.se/libcurl/c/libcurl-errors.html) for http://192.168.5.128/feeds/MP_WXS_3925660753.atom

但是仔细看报错日志，我的服务端口明明是 8109 但是 ttrss 却访问了 80，暂时不知是不是 ttrss 的 BUG，所以我便换了一个 nginx 代理的本地服务来反代 wewe-rss 的服务，由于我 nginx 配置了一个自签名的证书，客户端信任这个证书之后可以开启一些自部署服务只能 https 才能开启的功能，比如密码管理器 vaultwarden 。扯远了，回到正题，现在我已经配置好了反代的服务，新的订阅服务链接为：https://wewe.linkzz.hm/feeds/MP_WXS_3925660753.atom，但是直接在 ttrss 中配置还是会报错证书无法信任，所以这就来解决这个问题。

2. 信任证书

以下的操作是基于 Ubuntu 2204 版本，其他发行版没测试过。

2.1 确认证书类型

我是使用的 mkcert 生成的 CA 证书，证书包含 rootCA.crt 和 rootCA.pem 文件，crt 是二进制文件，只包含证书内容，在 windows 环境下可以直接安装，而 pem 是 base64 编码的文本文件，它包含了证书内容、证书链等信息，在 Ubuntu 中信任证书需要 pem 文件。

2.2 宿主机信任证书

因为可能不止一个容器需要信任证书，所以选择先在宿主机信任证书，然后映射宿主机的证书文件夹到容器，这样宿主机和容器都能达到信任证书的效果。

拷贝证书文件

cp your_pem.pem /usr/local/share/ca-certificates/rootCA.crt

注意后缀名需要重命名为 crt

更新证书

# 如果没安装 ca-certificates 需要先安装 ca-certificates
# apt install ca-certificates
update-ca-certificates

如果提示 command not found 安装 ca-certificates 软件包即可

Updating certificates in /etc/ssl/certs…
rehash: warning: skipping ca-certificates.crt,it does not contain exactly one certificate or CRL
1 added, 0 removed; done.
Running hooks in /etc/ca-certificates/update.d…
done.

上面日志没有报错提示添加了1个证书，表示添加信任证书成功。

运行 curl 验证一下：

curl -v https://wewe.linkzz.hm/feeds/MP_WXS_3925660753.atom

*   Trying 192.168.5.120:443…
* TCP_NODELAY set
* Connected to wewe.linkzz.hm (192.168.5.120) port 443 (#0)
* ALPN, offering h2
* ALPN, offering http/1.1
* successfully set certificate verify locations:
*   CAfile: /etc/ssl/certs/ca-certificates.crt
  CApath: /etc/ssl/certs
* TLSv1.3 (OUT), TLS handshake, Client hello (1):
* TLSv1.3 (IN), TLS handshake, Server hello (2):
* TLSv1.2 (IN), TLS handshake, Certificate (11):
* TLSv1.2 (IN), TLS handshake, Server key exchange (12):
* TLSv1.2 (IN), TLS handshake, Server finished (14):
* TLSv1.2 (OUT), TLS handshake, Client key exchange (16):
* TLSv1.2 (OUT), TLS change cipher, Change cipher spec (1):
* TLSv1.2 (OUT), TLS handshake, Finished (20):
* TLSv1.2 (IN), TLS handshake, Finished (20):
* SSL connection using TLSv1.2 / ECDHE-RSA-AES128-GCM-SHA256
* ALPN, server accepted to use http/1.1
* Server certificate:
*  subject: O=mkcert development certificate; OU=LINKZZ-LAPTOP\linkzz@linkzz-laptop (linkzz)
*  start date: Dec 18 01:59:08 2023 GMT
*  expire date: Mar 18 01:59:08 2026 GMT
*  subjectAltName: host "wewe.linkzz.hm" matched cert's "*.linkzz.hm"
*  issuer: O=mkcert development CA; OU=LINKZZ-LAPTOP\linkzz@linkzz-laptop (linkzz); CN=mkcert LINKZZ-LAPTOP\linkzz@linkzz-laptop (linkzz)
*  SSL certificate verify ok.
> GET /feeds/MP_WXS_3925660753.atom HTTP/1.1
> Host: wewe.linkzz.hm
> User-Agent: curl/7.68.0
> Accept: */*
>
* Mark bundle as not supporting multiuse
< HTTP/1.1 200 OK
< Server: nginx/1.18.0 (Ubuntu)
< Date: Wed, 10 Apr 2024 09:14:46 GMT
< Content-Type: application/atom+xml; charset=utf-8
< Content-Length: 3944
< Connection: keep-alive
< X-Powered-By: Express
< Access-Control-Allow-Origin: *
< Access-Control-Expose-Headers: authorization
< ETag: W/"f68-vmfb7ZvVPKMACdW27xekYBF0xLA"
<
<?xml version="1.0" encoding="utf-8"?>

可以看到已经正常响应了。

2.3 映射到容器证书目录

下面更新 ttrss 的容器映射，将宿主机的 /etc/ssl/certs 文件夹映射到容器相同目录 /etc/ssl/certs 即可，我的是 compose 运行的，更新 docker compsoe 文件：

version: "3"
services:
  service.rss:
    image: wangqiru/ttrss:latest
    container_name: ttrss
    ports:
      - 181:80
    environment:
      - SELF_URL_PATH=https://ttrss.linkzz.hm:443/ # please change to your own domain
      - DB_PASS=ttrss_bac # use the same password defined in `database.postgres`
      - PUID=1000
      - PGID=1000
    volumes:
      - feed-icons:/var/www/feed-icons/
      - /etc/ssl/certs:/etc/ssl/certs
    networks:
      - public_access
      - service_only
      - database_only
    stdin_open: true
    tty: true
    restart: always

  service.mercury: # set Mercury Parser API endpoint to `service.mercury:3000` on TTRSS plugin setting page
    image: wangqiru/mercury-parser-api:latest
    container_name: mercury
    networks:
      - public_access
      - service_only
    restart: always

  service.opencc: # set OpenCC API endpoint to `service.opencc:3000` on TTRSS plugin setting page
    image: wangqiru/opencc-api-server:latest
    container_name: opencc
    environment:
      - NODE_ENV=production
    networks:
      - service_only
    restart: always

  database.postgres:
    image: postgres:13-alpine
    container_name: postgres
    environment:
      - POSTGRES_PASSWORD=ttrss_bac # feel free to change the password
    volumes:
      - ~/postgres/data/:/var/lib/postgresql/data # persist postgres data to ~/postgres/data/ on the host
    networks:
      - database_only
    restart: always

  # utility.watchtower:
  #   container_name: watchtower
  #   image: containrrr/watchtower:latest
  #   volumes:
  #     - /var/run/docker.sock:/var/run/docker.sock
  #   environment:
  #     - WATCHTOWER_CLEANUP=true
  #     - WATCHTOWER_POLL_INTERVAL=86400
  #   restart: always

volumes:
  feed-icons:

networks:
  public_access: # Provide the access for ttrss UI
  service_only: # Provide the communication network between services only
    internal: true
  database_only: # Provide the communication between ttrss and database only
    internal: true

重启容器即可生效。

正常订阅的截图：

3. 总结

自签名证书对于有很多自部署在 nas 或者内部服务器，不方便公用服务申请证书的服务是很方便的，今天更新了容器中添加自信任证书的方法，总结就是先宿主机信任自签名证书，然后将 curl 等命令需要用到的证书文件夹 /etc/ssl/certs/ 文件夹直接映射到容器中国即可。

Docker 环境下的 qBittorrent 容器迁移至 lxc 保留配置

Tue, 09 Apr 2024 00:00:00 +0000

1. 背景

我的 qBittorrent 下载器是部署在 Docker 容器中的，而这个 Docker 的宿主机是一个 pve 的容器，他有一个独立的 IP,这个 IP 的网关指向了一个透明网关以实现大陆网络优化（国内特色），关于我的网络拓扑可以查看我以前的这篇文章但是下载器的流量经过 clash 之后需要单独对 BT 流量命中规则，我用的是 clash-meta 的核心，支持逻辑规则，于是我是这样写的：

# bt下载全直连
- AND,((SRC-IP-CIDR,192.168.5.128/32),(NOT,((DST-PORT,443)))),DIRECT

以上规则解释就是：来自 192.168.5.128IP 的目标端口非 443 的连接全直连，比较简单粗暴一刀切，但是这个规则还是会误杀一部分的流量，但至少可以避免大部分的 BT 流量了。

虽然问题是暂时解决了，但这个方案并不是最优，存在以下坑：

如果 Docker 的宿主机 IP 换了规则得更新
目标端口 80 的流量也应该继续下面的规则匹配 (当然这是因为懒没加到规则里面)
会误杀掉一部分的流量

2. 迁移

为了解决上面提到的问题，也为了把 qbittorrent 版本升级一下，我决定单独给他一个创建一个 lxd 容器，这样可以将网络直接指向上级网关，不必走透明网关。

2.1 创建容器

通过 pve 的内置 pct 命令创建容器：

pct create 117 \
	ugreen:vztmpl/archlinux-base_20230608-1_amd64.tar.zst \
	--cores 6 \
	--memory 512 \
	--hostname qbit \
	--net0 name=eth0,bridge=vmbr0 \
	--features mount="nfs;cifs" \
	--swap 512 \
	--rootfs volume=local-lvm:8

2.2 设置容器

这样就创建好了一个基于 archlinux 的 ct 容器，接下来启动进入容器简单设置一下：

启动容器：

pct start 117

进入容器：

pct enter 117

修改网络开启 dhcp 自动获取 IP

vi /etc/systemd/network/eth0.network

[Match]
Name = eth0

[Network]
Description = Interface eth0 autoconfigured by PVE
DHCP = yes
IPv6AcceptRA = false

将 DHCP 改为 yes, 重启网络服务

systemctl restart systemd-networkd

以上内容均可以通过 pve 的 webui 界面完成。

2.3 迁移配置 qbittorrent-nox

在 headless 无头环境下运行 qbittorrent 我们需要下载 qbittorrent-nox，nox -> no X server，没有 X 服务，外国人还是会起名。

archlinux 下直接通过包管理器安装即可，版本也是当下最新的 4.6.4 版本

pacman -S qbittorrent-nox

启动 qbittorrent-nox

systemctl enable qbittorrent-nox && systemctl start qbittorrent-nox

将 Docker 容器中的 qbittorrent 配置文件迁移到 ~/.config/qBittorrent/qBittorrent.conf 中，我的是 v4.4.3.1 迁移到 v4.6.4，迁移比较平滑，我所有的配置都继承了下来，如果是更低版本就不好说了，可以选择性的迁移。

2.4 下载数据迁移

原来的下载数据种子文件保留在 BT_backup 文件夹中，在 Docker 容器和新的配置文件下载路径一致的情况下可以平滑迁移，qbittorrent 不会报文件丢失，当然如果不需要迁移的话直接忽略掉就好了。

将 BT_backup 文件夹内容复制到新的 qbittorrent 数据文件夹下相应的位置即可。

3. 结语

此次迁移过程还是很顺利的，毕竟版本的变化也没那么大，由此我们可以学习下优质开源项目的向下兼容，破坏性的变化引入应该是很谨慎的。

看下迁移后的截图，新的 UI 界面图标太丑了🤣

甲骨文免费Arm主机新玩法-云安卓手机

Wed, 06 Dec 2023 00:00:00 +0000

1. 前言

我的一篇文章中有提到过云安卓手机的项目-redroid，该项目基于容器技术，构建一个安卓的运行时，同时通过Linux的内核模块，支持调用宿主机的硬件资源，同时其可运行于 x86 架构之上，通过转译来运行仅支持 arm 架构的安卓应用，用来跑app测试可以一试，正好甲骨文的arm主机资源没有好好利用，今天就来折腾一下这个玩法。

2. 加载内核模块 ashmem_linux、binder_linux

2.1 基于 `Ubuntu 20.04` 以上发行版

这两个模块是容器运行必须的内核模块，按照官方文档，在 Ubuntu 20.04 以上版本中，这两个模块已经编译到内核里了，可以直接 modprobe 命令加载，所以如果你的 arm服务器 正好是Ubuntu 20.04 以上版本，按照一下命令即可运行：

# 安装额外内核模块
apt install linux-modules-extra-`uname -r`
# 加载内核模块
modprobe binder_linux devices="binder,hwbinder,vndbinder"
modprobe ashmem_linux

# 运行容器
docker run -itd --rm --privileged \
    --pull always \
    -v ~/data:/data \
    -p 5555:5555 \
    redroid/redroid:11.0.0-latest \
    androidboot.redroid_gpu_mode=guest

2.2 Oracle Linux 8

否则如果你像我一样开主机的时候选了 Oracle Linux 8 的话，很遗憾，官方没有该系统的运行文档，以上两个内核模块也并没有编译，奈何我对该发行版不熟，升级了官方内核到 5.10 版本来编译redroid提供的两个内核模块的源码，最终用 amazonlinux2 的分支可已正常编译ashmem模块，然而另一个 binder 模块始终无法编译成功。

# Amadevel-uname-r == `uname -r`"
sudo make # build kernel modules
sudo make install # build and install *unsigned* kernel modules

2.3 Debian 10

于是我又想到了，Ubuntu 起源于 Debian，那倘若我将系统dd成Debian是否就可以正常加载这些内核模块了呢，于是我找到了一个手动重装的教程该教程基于网络安装，是走的官方渠道获取的系统镜像，不用担心被植入后门，这也是为什么不选择那些 一键dd脚本 的原因，缺点是只能安装 Debian 10 ，较新的 Debian 11 只能装完之后再寻求升级方法了。

比较顺利系统安装成功之后顺利登录系统，看了一下系统内核版本是 4.19 版本，还是有点老，于是从官方库升级了一下最新的稳定版内核 5.10 ，~~开始编译以上两个模块，这次很顺利编译成功了（虽然报了几个警告）~~，看了官方内核已经编译了两个内核模块，果然和 Ubuntu 20.04 以上版本一样，2个内核模块都可以加载。按照官方的教程开始运行容器：

# 加载内核模块
modprobe ashmem_linux
modprobe binder_linux devices=binder1,binder2,binder3,binder4,binder5,binder6
# 修改权限
chmod 666 /dev/binder*
chmod 666 /dev/ashmem

# 运行容器
docker run -itd --rm --privileged \
    --pull always \
    -v /dev/binder1:/dev/binder \
    -v /dev/binder2:/dev/hwbinder \
    -v /dev/binder3:/dev/vndbinder \
    -v ~/data11:/data \
    -p 5555:5555 \
    --name redroid11 \
    redroid/redroid:11.0.0-latest \
    androidboot.redroid_gpu_mode=guest

# adb 连接容器
adb connect arm-2

# scrcpy 连接
scrcpy -e

然而在 scrcpy 连接容器的时候却报了个错：

[server] ERROR: Could not create default video encoder for h264
List of video encoders:
    (none)
[server] ERROR: Exception on thread Thread[video,5,main]
java.lang.IllegalArgumentException: Failed to initialize video/avc, error 0xfffffffe (NAME_NOT_FOUND)
	at android.media.MediaCodec.native_setup(Native Method)
	at android.media.MediaCodec.<init>(MediaCodec.java:2000)
	at android.media.MediaCodec.<init>(MediaCodec.java:1978)
	at android.media.MediaCodec.createEncoderByType(MediaCodec.java:1933)
	at com.genymobile.scrcpy.ScreenEncoder.createMediaCodec(ScreenEncoder.java:229)
	at com.genymobile.scrcpy.ScreenEncoder.streamScreen(ScreenEncoder.java:73)
	at com.genymobile.scrcpy.ScreenEncoder.lambda$start$0$com-genymobile-scrcpy-ScreenEncoder(ScreenEncoder.java:294)
	at com.genymobile.scrcpy.ScreenEncoder$$ExternalSyntheticLambda0.run(Unknown Source:4)
	at java.lang.Thread.run(Thread.java:1012)
INFO: Renderer: opengl
INFO: OpenGL version: 4.6 (Compatibility Profile) Mesa 22.3.3
INFO: Trilinear filtering enabled

scrcpy报告找不到有效的视频编码器，然而虽然甲骨文的arm主机没有给gpu资源，但是看了用cpu 编码也是可行的呀，为啥运行不了，最终在这个 Issue 下面找到了答案，那即是在编译的内核中需要启用内核 codec2 的支持，于是最终还是走到了自己编译内核这步。

2.4 自编译Debian的内核

Debian的内核源码以软件包的方式提供，我们搜索一下最新的源码包：

➜  ~ apt search ^linux-source
Sorting... Done
Full Text Search... Done
linux-source/oldstable 5.10.197-1 all
  Linux kernel source (meta-package)

linux-source-5.10/oldstable,now 5.10.197-1 all
  Linux kernel source for version 5.10 with Debian patches

可以看到最新的 5.10 的源码，安装:

sudo apt install linux-source-5.10

在用户目录中编译：

# 创建目录
mkdir ~/kernel; cd ~/kernel
# 解压内核源码
tar -xaf /usr/src/linux-source-5.10.tar.xz

至于为什么不在 /usr/src 目录中用 root 编译，官方是这么说的, 我认为非常合理：

传统上，Linux内核源代码放置于 /usr/src/linux/，需要root权限才能编译。但是，在不需要时应避免使用管理员权限。src 群组的成员也可以使用该文件夹，但是应避免使用 /usr/src/。把核心源代码置于个人文件夹时，应把安全放在第一位：在 /usr/ 内的文件都应明确其在软件包系统内的作用，试图收集内核使用的信息时，不能在读取 /usr/src/linux 时误导程序。

配置内核:

# 先将原本的内核配置保留，在原基础上修改
cp /boot/config-5.10.0-26-arm64 ~/kernel/linux-source-5.10/.config
vim ~/kernel/linux-source-5.10/.config

修改一下内容：

CONFIG_DMABUF_HEAPS=y
CONFIG_DMABUF_HEAPS_SYSTEM=y
CONFIG_ANDROID_BINDERFS=y
CONFIG_ANDROID_BINDER_DEVICES="binder,hwbinder,vndbinder"

开始编译：

make deb-pkg LOCALVERSION=-falcot KDEB_PKGVERSION=$(make kernelversion)-1

开始漫长的等待，期间有可能提示缺少某个包之类的，按照提示处理一下即可，处理编译建议单线程，然后经过2天试错之后终于编译完成。安装内核：

sudo dpkg -i ../linux-image*.deb
# 重启
sudo reboot

重启之后重复 2.3 的运行步骤即可成功运行, 运行后的一下截图：

运行效果：

3. 结语

从上一张的GIF运行效果图相比大家也不难看出，这个云安卓的效率也不是很强，虽然能运行安卓应用，但是帧数很低，这是因为以下几个原因：

网络问题：

我的主机位置在韩国春川，家宽为联通，最近两边的网络延迟已经飙升到200了，还时常伴随丢包，所以操作有很大延迟，对延迟很敏感的应用肯定不适合运行。
配置问题：

我开了2台Arm，所以这台的配置为 2C12G 没有硬件加速的情况下cpu压力太大，下面是运行抖音播放视频时的资源占用截图：

容器问题：

容器在用纯CPU下仅有15Hz的刷新率，使得在源头上就不可能流畅。

总结：适合用来做一些静态应用的测试，或者一些挂机的应用，日常使用还是算了。

Docker on Linkzz's Blog

内网自部署存储迁移到自部署的 S3

内网自部署存储迁移到自部署的 S3

1. 存储的烦恼

2. 部署 Rustfs

2.1 使用 AWS CLI 测试访问

3. 使用 Rustfs 存储数据

3.1 Affine

3.2 Gitea

3.3 Memos

4. 总结

自签名证书部署内网 https 版 lobe-chat

1. 背景

2. 官方脚本部署

2.1 脚本部署

2.2 排查问题

3. 自签名证书的问题

3.1 忽略证书错误

3.2 挂载宿主机证书目录

4. 结语

简单记录一下 Docker 容器中信任一个自签名证书的案例

1. 背景

2. 信任证书

2.1 确认证书类型

2.2 宿主机信任证书

2.3 映射到容器证书目录

3. 总结

Docker 环境下的 qBittorrent 容器迁移至 lxc 保留配置

1. 背景

2. 迁移

2.1 创建容器

2.2 设置容器

2.3 迁移配置 qbittorrent-nox

2.4 下载数据迁移

3. 结语

甲骨文免费Arm主机新玩法-云安卓手机

1. 前言

2. 加载内核模块 ashmem_linux、binder_linux

2.1 基于 Ubuntu 20.04 以上发行版

2.2 Oracle Linux 8

2.3 Debian 10

2.4 自编译Debian的内核

3. 结语

2.1 基于 `Ubuntu 20.04` 以上发行版