Jenkins 企业级集成实战：从规划到落地的完整指南

会飞的大可2026-04-02 10:03

Jenkins 企业级集成实战：从规划到落地的完整指南

一、前期规划：不打无准备之仗

1.1 明确集成目标

在动手之前，我们需要回答几个关键问题：

维度 关键问题 典型场景
业务目标 要解决什么痛点？ 发布周期长、人工操作多、回滚困难
集成范围 覆盖哪些环节？ 代码构建→测试→部署→监控
工具链 与哪些系统集成？ GitLab、Harbor、Kubernetes、钉钉
安全合规 权限如何管控？ 分环境权限、审计日志、密钥管理

1.2 架构设计建议

复制代码 
┌─────────────────────────────────────────────────────────┐
│                    开发者/测试人员                        │
└────────────────────┬────────────────────────────────────┘
                     │ 提交代码
                     ▼
┌─────────────────────────────────────────────────────────┐
│  GitLab/GitHub  │  Webhook 触发                         │
└────────────────────┬────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────┐
│  Jenkins Master  │  任务调度、权限管理、日志聚合           │
│  (高可用部署)     │                                       │
└────────────────────┬────────────────────────────────────┘
                     │ 分发任务
                     ▼
┌─────────────────────────────────────────────────────────┐
│  Jenkins Agent   │  执行构建、测试、部署任务               │
│  (多节点/容器化)  │  按环境划分：build-agent/test-agent/prod-agent │
└────────────────────┬────────────────────────────────────┘
                     │
        ┌────────────┼────────────┐
        ▼            ▼            ▼
   ┌─────────┐  ┌─────────┐  ┌─────────┐
   │  Harbor │  │  Sonar  │  │   K8s   │
   │ 镜像仓库 │  │ 代码扫描 │  │ 生产集群 │
   └─────────┘  └─────────┘  └─────────┘

1.3 资源规划清单

组件 配置建议 数量 备注
Jenkins Master 4C8G 2 主备部署，避免单点
Build Agent 4C8G 2-3 编译型项目需更高配置
Test Agent 2C4G 2 运行自动化测试
Prod Deploy Agent 2C4G 1 仅部署操作，权限严格
存储 500GB+ 1 构建产物、日志归档

二、环境准备：基础设施搭建

2.1 Jenkins Master 部署（Docker Compose 方式）

为什么选择 Docker？

  • 快速部署、易于迁移
  • 版本控制（Infrastructure as Code）
  • 与宿主机隔离，避免环境污染

docker-compose.yml 配置：

yaml 复制代码 
version: '3.8'

services:
  jenkins:
    image: jenkins/jenkins:2.426.2-lts
    container_name: jenkins-master
    user: root  # 需要root权限来安装额外工具
    ports:
      - "8080:8080"   # Web 界面
      - "50000:50000" # Agent 通信端口
    volumes:
      - jenkins_home:/var/jenkins_home
      - /var/run/docker.sock:/var/run/docker.sock  # 容器内调用宿主机Docker
      - /usr/bin/docker:/usr/bin/docker
    environment:
      - JAVA_OPTS=-Djenkins.install.runSetupWizard=false  # 跳过初始化向导（生产环境建议保留）
      - JENKINS_OPTS=--prefix=/jenkins  # 添加URL前缀（可选）
    restart: unless-stopped
    networks:
      - jenkins-network

  # Nginx 反向代理（可选，用于HTTPS）
  nginx:
    image: nginx:alpine
    container_name: jenkins-nginx
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
      - ./ssl:/etc/nginx/ssl:ro
    depends_on:
      - jenkins
    networks:
      - jenkins-network

volumes:
  jenkins_home:

networks:
  jenkins-network:
    driver: bridge

nginx.conf 配置（HTTPS 示例）：

nginx 复制代码 
server {
    listen 80;
    server_name jenkins.yourcompany.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl;
    server_name jenkins.yourcompany.com;

    ssl_certificate /etc/nginx/ssl/jenkins.crt;
    ssl_certificate_key /etc/nginx/ssl/jenkins.key;

    location / {
        proxy_pass http://jenkins:8080;
        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;
        
        # WebSocket 支持（用于 Blue Ocean）
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

2.2 启动与初始化

bash 复制代码 
# 1. 创建目录结构
mkdir -p /opt/jenkins/{data,ssl}
cd /opt/jenkins

# 2. 启动服务
docker-compose up -d

# 3. 查看初始密码（如果跳过了向导）
docker exec jenkins-master cat /var/jenkins_home/secrets/initialAdminPassword

# 4. 安装常用插件（通过 Jenkins CLI 或手动）
# 推荐插件列表：Git、Pipeline、Blue Ocean、Kubernetes、Credentials Binding

三、核心配置：打造企业级流水线

3.1 凭据管理（Credentials）

安全原则：绝不将密码硬编码在代码或配置中！

配置路径 ：Manage Jenkins → Manage Credentials → System → Global credentials

凭据类型 使用场景 配置示例
Username with password GitLab 登录、Harbor 推送 gitlab-ci-token / harbor-robot
SSH Username with private key Git 仓库 SSH 协议 部署密钥
Secret file Kubeconfig、证书文件 production-kubeconfig
Secret text API Token、Webhook Secret dingtalk-webhook-token

实战技巧：按环境创建凭据域（Domain）

  • global：通用凭据
  • dev-environment：开发环境专用
  • prod-environment：生产环境专用（严格限制访问权限）

3.2 节点管理（Nodes）

配置路径 ：Manage Jenkins → Manage Nodes and Clouds

静态 Agent 配置（传统方式）：

bash 复制代码 
# 在 Agent 服务器上执行，连接 Master
curl -sO http://jenkins-master:8080/jnlpJars/agent.jar
java -jar agent.jar -jnlpUrl http://jenkins-master:8080/computer/agent-01/slave-agent.jnlp -secret xxx -workDir "/home/jenkins/agent"

推荐：动态 Agent（Kubernetes 插件）

yaml 复制代码 
# 配置 Cloud → Kubernetes
kubernetes:
  name: "kubernetes"
  serverUrl: "https://kubernetes.default"
  namespace: "jenkins"
  jenkinsUrl: "http://jenkins:8080"
  jenkinsTunnel: "jenkins:50000"
  containerCapStr: "10"
  
  # Pod 模板（Agent 定义）
  templates:
    - name: "maven-agent"
      label: "maven"
      containers:
        - name: "maven"
          image: "maven:3.9-eclipse-temurin-17"
          ttyEnabled: true
          command: "cat"
          resourceRequestCpu: "500m"
          resourceRequestMemory: "512Mi"
          resourceLimitCpu: "2000m"
          resourceLimitMemory: "2048Mi"
      volumes:
        - hostPathVolume:
            hostPath: "/var/run/docker.sock"
            mountPath: "/var/run/docker.sock"

3.3 共享库（Shared Library）

为什么需要？ 避免每个项目重复编写相同流水线逻辑，实现标准化。

目录结构：

复制代码 
(shared-library)
├── vars/                    # 全局变量/步骤
│   ├── standardPipeline.groovy
│   ├── dockerBuild.groovy
│   └── k8sDeploy.groovy
├── src/                     # Groovy 源码
│   └── com/company/
│       └── Utils.groovy
├── resources/               # 非 Groovy 文件
│   └── k8s-template.yaml
└── README.md

vars/standardPipeline.groovy 示例：

groovy 复制代码 
#!/usr/bin/env groovy

def call(Map config) {
    pipeline {
        agent {
            kubernetes {
                yaml """
apiVersion: v1
kind: Pod
spec:
  containers:
  - name: maven
    image: maven:3.9-eclipse-temurin-17
    command: ['cat']
    tty: true
  - name: docker
    image: docker:24-dind
    securityContext:
      privileged: true
  - name: kubectl
    image: bitnami/kubectl:latest
    command: ['cat']
    tty: true
"""
            }
        }
        
        options {
            buildDiscarder(logRotator(numToKeepStr: '10'))
            timeout(time: 30, unit: 'MINUTES')
            disableConcurrentBuilds()
        }
        
        environment {
            APP_NAME = "${config.appName ?: 'myapp'}"
            DOCKER_REGISTRY = "harbor.yourcompany.com"
            IMAGE_TAG = "${env.GIT_COMMIT.take(7)}-${env.BUILD_NUMBER}"
        }
        
        stages {
            stage('检出代码') {
                steps {
                    checkout scm
                    script {
                        env.GIT_BRANCH = sh(returnStdout: true, script: 'git rev-parse --abbrev-ref HEAD').trim()
                        echo "当前分支: ${env.GIT_BRANCH}"
                    }
                }
            }
            
            stage('单元测试') {
                steps {
                    container('maven') {
                        sh 'mvn clean test'
                    }
                }
                post {
                    always {
                        junit 'target/surefire-reports/*.xml'
                    }
                }
            }
            
            stage('代码扫描') {
                when {
                    anyOf {
                        branch 'main'
                        branch 'develop'
                    }
                }
                steps {
                    container('maven') {
                        withSonarQubeEnv('SonarQube') {
                            sh """
                                mvn sonar:sonar \
                                  -Dsonar.projectKey=${APP_NAME} \
                                  -Dsonar.projectName=${APP_NAME} \
                                  -Dsonar.java.binaries=target/classes
                            """
                        }
                    }
                }
            }
            
            stage('构建镜像') {
                steps {
                    container('docker') {
                        script {
                            def image = docker.build("${DOCKER_REGISTRY}/library/${APP_NAME}:${IMAGE_TAG}")
                            docker.withRegistry("https://${DOCKER_REGISTRY}", 'harbor-credentials') {
                                image.push()
                                image.push('latest')
                            }
                        }
                    }
                }
            }
            
            stage('部署到开发环境') {
                when {
                    branch 'develop'
                }
                steps {
                    container('kubectl') {
                        sh """
                            sed -e 's|{{IMAGE}}|${DOCKER_REGISTRY}/library/${APP_NAME}:${IMAGE_TAG}|g' \
                                -e 's|{{ENV}}|dev|g' \
                                k8s/deployment.yaml | kubectl apply -f - -n dev
                        """
                    }
                }
            }
            
            stage('部署到生产环境') {
                when {
                    branch 'main'
                }
                steps {
                    // 需要人工审批
                    input message: '确认部署到生产环境？', ok: '确认部署'
                    
                    container('kubectl') {
                        withCredentials([kubeconfigFile(credentialsId: 'prod-kubeconfig', variable: 'KUBECONFIG')]) {
                            sh """
                                sed -e 's|{{IMAGE}}|${DOCKER_REGISTRY}/library/${APP_NAME}:${IMAGE_TAG}|g' \
                                    -e 's|{{ENV}}|prod|g' \
                                    k8s/deployment.yaml | kubectl apply -f - -n prod
                                
                                # 等待滚动更新完成
                                kubectl rollout status deployment/${APP_NAME} -n prod --timeout=300s
                            """
                        }
                    }
                }
            }
        }
        
        post {
            failure {
                dingtalk (
                    robot: 'jenkins-dingtalk',
                    type: 'MARKDOWN',
                    title: "构建失败: ${APP_NAME}",
                    text: [
                        "### ❌ 构建失败通知",
                        "- **项目**: ${APP_NAME}",
                        "- **分支**: ${env.GIT_BRANCH}",
                        "- **构建号**: #${env.BUILD_NUMBER}",
                        "- **提交人**: ${env.GIT_AUTHOR_NAME}",
                        "- [查看详情](${env.BUILD_URL})"
                    ].join('\n')
                )
            }
            success {
                script {
                    if (env.GIT_BRANCH == 'main' || env.GIT_BRANCH == 'develop') {
                        dingtalk (
                            robot: 'jenkins-dingtalk',
                            type: 'MARKDOWN',
                            title: "构建成功: ${APP_NAME}",
                            text: [
                                "### ✅ 构建成功",
                                "- **项目**: ${APP_NAME}",
                                "- **镜像**: `${DOCKER_REGISTRY}/library/${APP_NAME}:${IMAGE_TAG}`",
                                "- **部署环境**: ${env.GIT_BRANCH == 'main' ? '生产' : '开发'}",
                                "- [查看详情](${env.BUILD_URL})"
                            ].join('\n')
                        )
                    }
                }
            }
        }
    }
}

在 Jenkins 中配置共享库：

Manage Jenkins → System → Global Pipeline Libraries

  • Name: company-shared-library
  • Default version: main
  • Retrieval method: Modern SCM
  • Source Code Management: Git
  • Project Repository: https://gitlab.yourcompany.com/devops/shared-library.git
  • Credentials: gitlab-credentials

项目 Jenkinsfile 使用示例：

groovy 复制代码 
@Library('company-shared-library') _

standardPipeline(
    appName: 'order-service'
)

四、集成实战：连接生态工具

4.1 GitLab 集成（Webhook 触发）

Jenkins 端配置：

  1. 安装插件：GitLab Plugin、GitLab Hook Plugin
  2. 创建 Pipeline 任务 → 勾选 GitHub hook trigger for GITScm polling
  3. 生成 Secret Token：Build Triggers → Advanced → Generate

GitLab 端配置：

bash 复制代码 
# 项目 → Settings → Webhooks
URL: http://jenkins.yourcompany.com/project/order-service
Secret Token: <从 Jenkins 获取>
Trigger: Push events, Merge request events
SSL Verification: 如果 Jenkins 是内网 HTTP，需取消勾选

高级：根据分支过滤触发

groovy 复制代码 
// Jenkinsfile 中
triggers {
    gitlab(
        triggerOnPush: true,
        triggerOnMergeRequest: true,
        branchFilterType: 'NameBasedFilter',
        includeBranchesSpec: 'main,develop,release/*',
        secretToken: env.GITLAB_WEBHOOK_SECRET
    )
}

4.2 Harbor 镜像仓库集成

配置 Docker 信任仓库（Jenkins Agent）：

bash 复制代码 
# /etc/docker/daemon.json
{
  "insecure-registries": ["harbor.yourcompany.com"],
  "exec-opts": ["native.cgroupdriver=systemd"]
}

Jenkins 凭据配置：

  • 类型：Username with password
  • ID：harbor-credentials
  • Username：robot$jenkins
  • Password：Harbor 机器人账户 Token

4.3 Kubernetes 部署集成

RBAC 配置（ServiceAccount）：

yaml 复制代码 
# jenkins-service-account.yaml
apiVersion: v1
kind: ServiceAccount
metadata:
  name: jenkins-deployer
  namespace: jenkins
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: jenkins-deployer-role
rules:
- apiGroups: ["", "apps", "extensions"]
  resources: ["deployments", "services", "pods", "configmaps", "secrets"]
  verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: jenkins-deployer-binding
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: jenkins-deployer-role
subjects:
- kind: ServiceAccount
  name: jenkins-deployer
  namespace: jenkins

获取 Kubeconfig：

bash 复制代码 
# 创建 Token Secret
kubectl apply -f - <<EOF
apiVersion: v1
kind: Secret
metadata:
  name: jenkins-deployer-token
  namespace: jenkins
  annotations:
    kubernetes.io/service-account.name: jenkins-deployer
type: kubernetes.io/service-account-token
EOF

# 提取 Kubeconfig
TOKEN=$(kubectl get secret jenkins-deployer-token -n jenkins -o jsonpath='{.data.token}' | base64 -d)
CA_CERT=$(kubectl config view --raw -o jsonpath='{.clusters[0].cluster.certificate-authority-data}')
SERVER=$(kubectl config view --raw -o jsonpath='{.clusters[0].cluster.server}')

# 生成 kubeconfig 文件，上传到 Jenkins 凭据

4.4 钉钉/飞书通知集成

安装插件： DingTalk Plugin

流水线中使用：

groovy 复制代码 
post {
    always {
        script {
            def status = currentBuild.currentResult
            def emoji = status == 'SUCCESS' ? '✅' : (status == 'FAILURE' ? '❌' : '⚠️')
            
            dingtalk (
                robot: 'jenkins-dingtalk',
                type: 'ACTION_CARD',
                title: "${emoji} ${env.JOB_NAME} #${env.BUILD_NUMBER}",
                text: [
                    "![screenshot](https://your-logo.png)",
                    "### ${emoji} 构建${status == 'SUCCESS' ? '成功' : '失败'}",
                    "---",
                    "| 项目 | 值 |",
                    "|------|-----|",
                    "| 任务名称 | ${env.JOB_NAME} |",
                    "| 构建编号 | #${env.BUILD_NUMBER} |",
                    "| 构建状态 | ${status} |",
                    "| 持续时间 | ${currentBuild.durationString} |",
                    "| 触发原因 | ${currentBuild.buildCauses.shortDescription[0]} |",
                    "| 代码分支 | ${env.GIT_BRANCH} |",
                    "| 提交记录 | ${env.GIT_COMMIT?.take(8)} |"
                ].join('\n'),
                btns: [
                    [
                        title: '查看构建详情',
                        actionUrl: "${env.BUILD_URL}"
                    ],
                    [
                        title: '查看代码变更',
                        actionUrl: "${env.GIT_URL?.replace('.git', '')}/commit/${env.GIT_COMMIT}"
                    ]
                ]
            )
        }
    }
}

五、运维管理：稳定运行的保障

5.1 备份策略

必须备份的数据：

  • $JENKINS_HOME 完整目录（除 workspace、builds 可酌情排除）
  • 关键： config.xml、jobs/、users/、credentials.xml、plugins/

自动化备份脚本：

bash 复制代码 
#!/bin/bash
# jenkins-backup.sh

BACKUP_DIR="/backup/jenkins/$(date +%Y%m%d)"
JENKINS_HOME="/var/jenkins_home"
RETENTION_DAYS=30

mkdir -p ${BACKUP_DIR}

# 使用 tar 排除大文件
tar czf ${BACKUP_DIR}/jenkins-backup.tar.gz \
    --exclude='**/workspace/*' \
    --exclude='**/builds/*' \
    --exclude='**/caches/*' \
    -C ${JENKINS_HOME} .

# 上传到对象存储（可选）
aws s3 cp ${BACKUP_DIR}/jenkins-backup.tar.gz s3://company-backups/jenkins/

# 清理旧备份
find /backup/jenkins -type d -mtime +${RETENTION_DAYS} -exec rm -rf {} \;

5.2 监控告警

关键指标监控：

指标 告警阈值 检查方式
Master 磁盘使用率 > 80% Prometheus Node Exporter
构建队列等待数 > 10 Jenkins Metrics Plugin
Executor 使用率 > 90% 持续 5min Jenkins Prometheus Metrics
构建失败率 > 30% 过去 1h 自定义脚本统计
插件安全漏洞 发现即告警 Jenkins Security Advisory

Prometheus 抓取配置：

yaml 复制代码 
# prometheus.yml
scrape_configs:
  - job_name: 'jenkins'
    metrics_path: /prometheus
    static_configs:
      - targets: ['jenkins:8080']
    basic_auth:
      username: admin
      password_file: /etc/prometheus/jenkins_token

5.3 权限管理（RBAC）

推荐插件： Role-based Authorization Strategy

角色设计建议：

角色 权限范围 成员
admin 完全控制 运维经理、核心运维
ops 管理节点、配置系统 运维工程师
dev-lead 创建/配置任务、查看所有构建 开发组长
developer 执行构建、查看日志 普通开发
viewer 只读访问 测试、产品

配置示例：

复制代码 
Global roles:
  - admin: Overall/Administer
  - ops: Overall/Read, Agent/Configure, Agent/Create
  - developer: Overall/Read

Item roles（按项目前缀匹配）:
  - backend-role: pattern "backend-.*" → Job/Build, Job/Read, Job/Workspace
  - frontend-role: pattern "frontend-.*" → Job/Build, Job/Read

六、常见问题与解决方案

Q1: 构建速度太慢怎么办？

诊断步骤：

  1. 检查网络：是否每次构建都重新下载依赖？

    • 解决：使用 Nexus/Artifactory 作为 Maven/NPM 代理仓库

  2. 检查磁盘：是否使用机械硬盘？

    • 解决：Jenkins Home 迁移到 SSD

  3. 检查并行度：是否单线程构建？

    • 解决 ：Maven 添加 -T 1C 参数并行构建

  4. 使用缓存卷：

    groovy 复制代码 
    // Kubernetes Pod 模板中添加
volumes:
  - persistentVolumeClaim:
      claimName: maven-cache
      mountPath: /root/.m2

Q2: Agent 连接不稳定？

常见原因：

  • 网络超时：调整 Jenkins Manage Nodes → Advanced → Launch timeout 到 300s
  • JNLP 端口不通：检查防火墙 50000 端口
  • Agent 资源不足：监控 Agent 内存使用，避免 OOM

Q3: 凭证泄露风险？

防护措施：

  • 开启 Mask Passwords 插件，自动隐藏控制台输出中的密码
  • 使用 withCredentials 而不是环境变量直接暴露
  • 定期轮换凭据（Harbor 机器人账户设置 90 天过期）
  • 开启审计日志：Manage Jenkins → System Log → Add new log recorder

七、总结与进阶建议

已完成的里程碑

✅ Jenkins Master 高可用部署

✅ 多环境 Agent 架构

✅ 标准化 Pipeline 共享库

✅ GitLab → Jenkins → Harbor → K8s 完整链路

✅ 钉钉通知与监控告警

✅ RBAC 权限管控

下一步演进方向

  1. GitOps 转型：将 Jenkins 作为触发器，ArgoCD/Flux 接管部署
  2. 制品晋级：引入 Harbor 的复制策略，实现 dev → test → prod 镜像自动晋级
  3. 安全左移：集成 Snyk/Trivy 进行依赖漏洞扫描
  4. 可观测性：接入 OpenTelemetry，实现构建链路追踪

附录：快速检查清单

在将 Jenkins 投入生产前，确认以下事项：

  • Master 是否配置了定期备份？
  • 是否启用了矩阵授权而非匿名访问？
  • 生产环境部署是否设置了人工审批？
  • 是否配置了构建超时和并发限制？
  • 日志是否集中采集到 ELK/Loki？
  • 是否测试过灾难恢复流程？

寄语 ：

Jenkins 的价值不在于它本身，而在于它将团队从重复劳动中解放出来，让工程师专注于创造价值。建议从小范围试点开始，逐步推广，同时建立内部文档和培训机制，让工具真正成为团队的加速器而非负担。

如需针对特定场景（如 .NET 项目、移动端打包、数据库变更集成）的详细配置，欢迎在评论区留言讨论。

相关推荐
Are_You_Okkk_2 小时前
AI开源知识库跨部门闭环搭建，效率提升40%
大数据·运维·人工智能·架构·开源
AIminminHu2 小时前
OpenGL渲染与几何内核那点事-项目实践理论补充(一-2-(3)-当你的协同CAD服务器面临“千人同屏”时：从单机优化到分布式高并发)
运维·服务器·分布式
舰长1152 小时前
Diffie-Hellman Key Agreement Protocol 资源管理错误漏洞(CVE-2022-40735)【原理扫描】openssl升级
运维·服务器
xxjj998a2 小时前
若依部署Nginx和Tomcat
运维·nginx·tomcat
kyle~3 小时前
Linux---nmcli (NetworkManager服务的核心命令行工具)
linux·运维·php
不愿透露姓名的大鹏3 小时前
VMware vcenter报错no healthy upstream
linux·运维·服务器·vmware
zcongfly3 小时前
绿联云+rustdesk+tailscale自建服务器通信
运维·服务器
胡楚昊3 小时前
Polar PWN （4）
linux·运维·算法
桌面运维家3 小时前
虚拟化服务器备份恢复：快速切换方案详解
运维·服务器
热门推荐
012026年3月AI领域大事件：DeepSeek引领开源风暴02GitHub 镜像站点03Qwen3.5-Omni与Qwen3.6模型全面解析（含测评/案例/使用教程）04Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services05UV安装并设置国内源06让 Trae IDE 智能体 “读懂”文档 Excel+PDF+DOCX ：mcp-documents-reader 工具使用指南07“wsl --install -d Ubuntu-22.04”下载慢，中国地区离线安装 Ubuntu 22.04 WSL方法（亲测2025年5月6日）08围棋-html版本09AI 编程效率翻倍：Superpowers Skills 上手清单 + 完整指南10纯 HTML/CSS/JS 实现的高颜值登录页，还会眨眼睛！少女心爆棚！