部署MCSManager#

1. 创建docker-compose.yaml文件：

   1
   mkdir -p ~/docker_data/mcsm && cd ~/docker_data/mcsm && nano docker-compose.yaml
   

   1
   services:
   2
     web:
   3
       image: githubyumao/mcsmanager-web:latest
   4
       ports:
   5
         - 65004:23333 # 注意修改为自己的端口号
   6
       volumes:
   7
         - /etc/localtime:/etc/localtime:ro
   8
         - ./web/data:/opt/mcsmanager/web/data
   9
         - ./web/logs:/opt/mcsmanager/web/logs
   10
       network_mode: bridge
   11
       restart: unless-stopped
   12
   
   13
     daemon:
   14
       image: githubyumao/mcsmanager-daemon:latest
   15
       restart: unless-stopped
   16
       ports:
   17
         - 65005:24444 # 注意修改为自己的端口号
   18
         - 65008:25565 # 注意修改为自己的端口号
   19
       environment:
   20
   
   21
         - MCSM_DOCKER_WORKSPACE_PATH=/home/ubuntu/docker_data/mcsm/daemon/data/InstanceData
   22
       volumes:
   23
         - /etc/localtime:/etc/localtime:ro
   24
         - ./daemon/data:/opt/mcsmanager/daemon/data
   25
         - ./daemon/logs:/opt/mcsmanager/daemon/logs
   26
         - /var/run/docker.sock:/var/run/docker.sock
   27
       network_mode: bridge
   

2. 查看生成的daemon节点key，后续需要填入MCSManager面板中：

   1
   cat daemon/data/Config/global.json
   

   1
   {
   2
     "version": 2,
   3
     "ip": "",
   4
     "port": 24444,
   5
     "prefix": "",
   6
   
   7
     "key": "xxxxxxx",
   8
     "maxFileTask": 2,
   9
     "maxZipFileSize": 200,
   10
     "language": "zh_cn",
   11
     "defaultInstancePath": "",
   12
     "allocatablePortRange": [
   13
         10010,
   14
         65500
   15
     ],
   16
     "currentAllocatablePort": 10095,
   17
     "portAssignInterval": 5,
   18
     "uploadSpeedRate": 0,
   19
     "downloadSpeedRate": 0
   20
   }
   

3. 启动MCSManager服务

   1
   docker compose up -d
   

4. 访问MCSManager面板，地址为http://你的服务器IP:65004，按照web流程配置账户信息，然后进行Nginx反代（我反正添加本地节点有点问题，反代过后添加节点没问题）
5. 按照如下图片配置Nginx Proxy Manager反代
   • 前往Advanced Tab下的Custom Nginx Configuration，添加以下代码：

   1
   include /data/nginx/custom/cloudflare_ips.conf;
   2
   
   3
   # 传输时默认开启gzip压缩
   4
   gzip on;
   5
   
   6
   # 传输时会被压缩的类型(应当依据文件压缩效果添加)
   7
   gzip_types text/plain text/css application/javascript application/xml application/json;
   8
   
   9
   # 反向代理时，启用压缩
   10
   gzip_proxied any;
   11
   
   12
   # 传输时压缩等级，等级越高压缩消耗CPU越多，最高9级，通常5级就够了
   13
   gzip_comp_level 5;
   14
   
   15
   # 传输时大小达到1k才压缩，压缩小内容无意义
   16
   gzip_min_length 1k;
   17
   
   18
   # 最大文件上传大小限制。设置0为不限制
   19
   client_max_body_size 0;
   20
   
   21
   # 关闭缓存
   22
   proxy_request_buffering off;
   23
   proxy_buffering off;
   

6. 前往面板，按图添加节点

使用Github Action构建Minecraft服务器镜像#

这里以purpur端为例，其他端也可以参考类似的思路进行构建。需要什么插件可以自己加进去 我最终是推送到我自建的gitea，如果你要推送到ghcr，直接让AI改一下这个文件即可

1. 随便开个空仓库，开启Action
2. 创建purpur/Dockerfile文件

   1
   mkdir purpur && nano purpur/Dockerfile
   

   1
   ARG BASE_IMAGE=container-registry.oracle.com/graalvm/jdk:17
   2
   
   3
   # 使用变量作为基础镜像
   4
   FROM ${BASE_IMAGE}
   5
   
   6
   # 定义构建参数，可以从 build-push-action 传入
   7
   ARG MC_VERSION=1.20.4
   8
   ARG PURPUR_JAR_NAME=purpur.jar
   9
   
   10
   # 安装 curl 用于下载，并清理缓存
   11
   RUN microdnf install curl && \
   12
       microdnf clean all
   13
   
   14
   # 下载 Purpur 服务端
   15
   RUN curl -L -o /app/${PURPUR_JAR_NAME} \
   16
       "https://api.purpurmc.org/v2/purpur/${MC_VERSION}/latest/download"
   17
   
   18
   # 复制启动脚本到镜像中
   19
   COPY start.sh /app/start.sh
   20
   
   21
   # 给予启动脚本执行权限
   22
   RUN chmod +x /app/start.sh
   23
   
   24
   WORKDIR /workspace
   25
   
   26
   # 声明服务器数据卷，用于持久化世界、插件等数据
   27
   VOLUME /workspace
   28
   
   29
   # 暴露 Minecraft 服务器端口
   30
   EXPOSE 25565
   31
   
   32
   # 设置容器启动时执行的命令
   33
   CMD ["/app/start.sh"]
   

3. 创建purpur/start.sh启动脚本

   1
   nano purpur/start.sh
   

   1
   #!/bin/sh
   2
   
   3
   # 自动同意 Minecraft EULA
   4
   echo "eula=true" > eula.txt
   5
   
   6
   # 设置默认内存，如果环境变量 MEMORY 未设置，则使用 4G
   7
   MEMORY=${MEMORY:-4G}
   8
   
   9
   # 使用 Aikar's Flags 优化启动参数
   10
   # exec 会让 Java 进程替换掉 shell 进程，成为容器的主进程 (PID 1)，这样可以更好地接收 Docker 的停止信号
   11
   exec java -Xms${MEMORY} -Xmx${MEMORY} \
   12
       -XX:+UseG1GC \
   13
       -XX:+ParallelRefProcEnabled \
   14
       -XX:MaxGCPauseMillis=200 \
   15
       -XX:+UnlockExperimentalVMOptions \
   16
       -XX:+DisableExplicitGC \
   17
       -XX:+AlwaysPreTouch \
   18
       -XX:G1NewSizePercent=30 \
   19
       -XX:G1MaxNewSizePercent=40 \
   20
       -XX:G1HeapRegionSize=8M \
   21
       -XX:G1ReservePercent=20 \
   22
       -XX:G1HeapWastePercent=5 \
   23
       -XX:G1MixedGCCountTarget=4 \
   24
       -XX:InitiatingHeapOccupancyPercent=15 \
   25
       -XX:G1MixedGCLiveThresholdPercent=90 \
   26
       -XX:G1RSetUpdatingPauseTimePercent=5 \
   27
       -XX:SurvivorRatio=32 \
   28
       -XX:+PerfDisableSharedMem \
   29
       -XX:MaxTenuringThreshold=1 \
   30
       -Dusing.aikars.flags=https://mcflags.emc.gs \
   31
       -Daikars.new.flags=true \
   32
       -jar /app/purpur.jar --nogui
   

4. 创建一个purpur.yml文件

   1
   # .github/workflows/build-purpur.yml
   2
   # ----------------------------------------------------------------
   3
   # 这是一个用于构建 Minecraft Purpur 服务端 Docker 镜像的 GitHub Actions 工作流。
   4
   #
   5
   # 功能特性:
   6
   # 1. 多架构构建: 支持 amd64 和 arm64 架构。
   7
   # 2. 动态 Java 版本: 自动根据输入的 Minecraft 版本选择 Java 17 或 Java 21 作为基础镜像。
   8
   #    - MC >= 1.20.5 使用 Java 21
   9
   #    - MC < 1.20.5 使用 Java 17
   10
   # 3. 手动触发与版本控制: 支持手动触发并输入版本号，也支持通过 push 自动触发。
   11
   #    - 最终镜像标签为 <MC_VERSION>，例如 "1.20.5"。
   12
   #    - 各架构的中间镜像标签为 <MC_VERSION>-<arch>，例如 "1.20.5-amd64"。
   13
   # 4. 串行执行: 构建任务将按顺序执行（先完成 amd64，再开始 arm64），便于排错和控制并发。
   14
   # 5. 推送到私有 Gitea 仓库: 自动构建并推送到你自建的 Gitea 容器镜像仓库。
   15
   # ----------------------------------------------------------------
   16
   
   17
   name: Build Purpur Docker Image & Push to Gitea
   18
   
   19
   on:
   20
     # 允许在 GitHub Actions 页面手动触发
   21
     workflow_dispatch:
   22
       inputs:
   23
         mc_version:
   24
           description: 'Minecraft Version (e.g., 1.20.4, 1.20.5)'
   25
           required: true
   26
           default: '1.20.4'
   27
   
   28
   # 全局环境变量
   29
   env:
   30
     # 当 push 触发时使用的默认 Minecraft 版本
   31
     DEFAULT_MC_VERSION: "1.20.4"
   32
     # Gitea 上的镜像名称
   33
     GITEA_IMAGE_NAME: "purpur"
   34
     # 第一个需要 Java 21 的 Minecraft 版本，用于版本比较
   35
     JAVA_21_CUTOFF_VERSION: "1.20.5"
   36
   
   37
   jobs:
   38
     build-and-push-arch:
   39
       strategy:
   40
         fail-fast: false
   41
         # 设置最大并行数为 1，实现串行执行
   42
         max-parallel: 1
   43
         matrix:
   44
           include:
   45
             - arch: amd64
   46
               runner: ubuntu-latest
   47
             - arch: arm64
   48
               runner: ubuntu-22.04-arm
   49
   
   50
       runs-on: ${{ matrix.runner }}
   51
       permissions:
   52
         contents: read
   53
         packages: write
   54
   
   55
       steps:
   56
         - name: Checkout repository
   57
           uses: actions/checkout@v4
   58
   
   59
         - name: Determine Versions
   60
           id: get_versions
   61
           run: |
   62
             # 步骤 1: 确定 Minecraft 版本
   63
             # 如果是手动触发，则使用输入的版本号；否则，使用环境变量中定义的默认版本号
   64
             MC_VERSION=${{ github.event.inputs.mc_version || env.DEFAULT_MC_VERSION }}
   65
             echo "MC_VERSION=$MC_VERSION" >> $GITHUB_ENV
   66
             echo "Determined Minecraft version: $MC_VERSION"
   67
   
   68
             # 步骤 2: 根据 Minecraft 版本判断需要的 Java 版本
   69
             # 使用 dpkg 工具比较版本号，这比简单的字符串比较更可靠
   70
             if dpkg --compare-versions "$MC_VERSION" "ge" "${{ env.JAVA_21_CUTOFF_VERSION }}"; then
   71
               JAVA_TAG="21"
   72
               echo "Version $MC_VERSION requires Java 21."
   73
             else
   74
               JAVA_TAG="17"
   75
               echo "Version $MC_VERSION requires Java 17."
   76
             fi
   77
   
   78
             # 步骤 3: 设置基础镜像环境变量，供后续步骤使用
   79
             BASE_IMAGE="container-registry.oracle.com/graalvm/jdk:$JAVA_TAG"
   80
             echo "BASE_IMAGE=$BASE_IMAGE" >> $GITHUB_ENV
   81
             echo "Using base image: $BASE_IMAGE"
   82
   
   83
         - name: Set up Docker Buildx
   84
           uses: docker/setup-buildx-action@v3
   85
   
   86
         - name: Log in to Gitea Container Registry
   87
           uses: docker/login-action@v3
   88
           with:
   89
             registry: ${{ secrets.GITEA_HOST }}
   90
             username: ${{ secrets.GITEA_USERNAME }}
   91
             password: ${{ secrets.GITEA_REGISTRY_PAT }}
   92
   
   93
         - name: Build and push Docker image
   94
           id: buildx1
   95
           continue-on-error: true
   96
           uses: docker/build-push-action@v5
   97
           with:
   98
             context: ./purpur
   99
             file: ./purpur/Dockerfile
   100
             platforms: linux/${{ matrix.arch }}
   101
             build-args: |
   102
               MC_VERSION=${{ env.MC_VERSION }}
   103
               # 将动态决定的基础镜像名传递给 Dockerfile
   104
               BASE_IMAGE=${{ env.BASE_IMAGE }}
   105
             tags: ${{ secrets.GITEA_HOST }}/${{ secrets.GITEA_USERNAME }}/${{ env.GITEA_IMAGE_NAME }}:${{ env.MC_VERSION }}-${{ matrix.arch }}
   106
             push: true
   107
             # 禁用 provenance 和 sbom，避免创建额外的 manifest
   108
             provenance: false
   109
             sbom: false
   110
             cache-from: type=gha
   111
             cache-to: type=gha,mode=max
   112
         - name: Wait to retry
   113
           if: steps.buildx1.outcome != 'success'
   114
           run: |
   115
             sleep 10
   116
         - name: Build and push Docker image
   117
           if: steps.buildx1.outcome != 'success'
   118
           uses: docker/build-push-action@v5
   119
           with:
   120
             context: ./purpur
   121
             file: ./purpur/Dockerfile
   122
             platforms: linux/${{ matrix.arch }}
   123
             build-args: |
   124
               MC_VERSION=${{ env.MC_VERSION }}
   125
               # 将动态决定的基础镜像名传递给 Dockerfile
   126
               BASE_IMAGE=${{ env.BASE_IMAGE }}
   127
             tags: ${{ secrets.GITEA_HOST }}/${{ secrets.GITEA_USERNAME }}/${{ env.GITEA_IMAGE_NAME }}:${{ env.MC_VERSION }}-${{ matrix.arch }}
   128
             push: true
   129
             # 禁用 provenance 和 sbom，避免创建额外的 manifest
   130
             provenance: false
   131
             sbom: false
   132
             cache-from: type=gha
   133
             cache-to: type=gha,mode=max
   134
   
   135
     merge-manifest:
   136
       needs: build-and-push-arch
   137
       runs-on: ubuntu-latest
   138
       permissions:
   139
         contents: read
   140
         packages: write
   141
   
   142
       steps:
   143
         - name: Log in to Gitea Container Registry
   144
           uses: docker/login-action@v3
   145
           with:
   146
             registry: ${{ secrets.GITEA_HOST }}
   147
             username: ${{ secrets.GITEA_USERNAME }}
   148
             password: ${{ secrets.GITEA_REGISTRY_PAT }}
   149
   
   150
         - name: Determine Minecraft Version
   151
           # 在这个 job 中也需要确定版本号，以保持与上一个 job 一致
   152
           run: |
   153
             MC_VERSION=${{ github.event.inputs.mc_version || env.DEFAULT_MC_VERSION }}
   154
             echo "MC_VERSION=$MC_VERSION" >> $GITHUB_ENV
   155
   
   156
         - name: Create and push manifest list with version tag
   157
           run: |
   158
             IMAGE_BASE="${{ secrets.GITEA_HOST }}/${{ secrets.GITEA_USERNAME }}/${{ env.GITEA_IMAGE_NAME }}"
   159
             VERSION_TAG="${IMAGE_BASE}:${{ env.MC_VERSION }}"
   160
             AMD_TAG="${IMAGE_BASE}:${{ env.MC_VERSION }}-amd64"
   161
             ARM_TAG="${IMAGE_BASE}:${{ env.MC_VERSION }}-arm64"
   162
   
   163
             echo "--- Creating Manifest List for $VERSION_TAG ---"
   164
   
   165
             # 清理所有可能存在的旧 manifest（忽略错误）
   166
             echo "Cleaning up old manifests..."
   167
             docker manifest rm ${VERSION_TAG} 2>/dev/null || true
   168
             docker manifest rm ${AMD_TAG} 2>/dev/null || true
   169
             docker manifest rm ${ARM_TAG} 2>/dev/null || true
   170
   
   171
             # 检查架构特定镜像状态
   172
             echo "Checking image status..."
   173
             docker manifest inspect ${AMD_TAG} || echo "❌ amd64 image not found or is manifest list"
   174
             docker manifest inspect ${ARM_TAG} || echo "❌ arm64 image not found or is manifest list"
   175
   
   176
             # 检查架构镜像是否存在
   177
             if docker manifest inspect ${AMD_TAG} >/dev/null 2>&1 && docker manifest inspect ${ARM_TAG} >/dev/null 2>&1; then
   178
               echo "Both architecture images exist, creating manifest list..."
   179
   
   180
               # 由于架构标签可能是 manifest list，我们使用 --amend 来处理
   181
               docker manifest create ${VERSION_TAG} \
   182
                 --amend ${AMD_TAG} \
   183
                 --amend ${ARM_TAG}
   184
               docker manifest push ${VERSION_TAG}
   185
               echo "✅ Gitea manifest pushed successfully"
   186
             else
   187
               echo "❌ Architecture images not ready, skipping Gitea manifest creation"
   188
             fi
   189
   
   190
         - name: Inspect final manifest
   191
           run: |
   192
             echo "--- Inspecting Final Manifest ---"
   193
             docker manifest inspect ${{ secrets.GITEA_HOST }}/${{ secrets.GITEA_USERNAME }}/${{ env.GITEA_IMAGE_NAME }}:${{ env.MC_VERSION }}
   

5. 提交代码到GitHub，然后手动去触发Action构建镜像，输入你要的Minecraft版本，以下是当前支持版本（点击复制）： 加载中Purpur支持版本中...
6. 打包完成后，前往MCSManager面板，按照图片添加一个实例：
7. 运行完成后，还需要配置端口映射以及环境变量
8. 最后愉快的启动服务器吧！