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 项目、移动端打包、数据库变更集成）的详细配置，欢迎在评论区留言讨论。

相关推荐
荣--19 小时前
一键部署不是为了省时间 —— 它是把"买来的 PaaS"变成"自己的平台"的拐点
运维·zabbix·工程化·一键部署·平台化·边界设计
江华森20 小时前
动手实战学 Docker — 从零到集群编排完全指南
运维
Avan_菜菜1 天前
FRP 内网穿透完整实战：从 HTTP 映射到 HTTPS 自签代理
运维·nginx·https
SelectDB2 天前
Litefuse 开源并推出单进程轻量模式，25 秒就能跑起来的 Agent 可观测与评估平台
运维·后端·自动化运维
XIAOHEZIcode4 天前
Linux系统鼠标偏移常见原因以及修复方案
linux·运维·游戏
用户0328472220705 天前
如何搭建本地yum源(上)
运维
大树888 天前
金刚石散热越强，管路越先见顶
大数据·运维·服务器·人工智能·ai
摇滚侠8 天前
Linux CentOS7 rpm 安装 MySQL 5.7
linux·运维·mysql
霸道流氓气质8 天前
领域驱动设计（DDD）在 Spring Boot 微服务中的实践指南
运维·spring boot·微服务
Inhand陈工8 天前
基于台达PLC与映翰通IG502的智慧水产养殖精准投喂与远程运维解决方案
运维·人工智能·物联网·阿里云·信息与通信
热门推荐
012026年6月AI大模型全景报告：GPT-5.6、Claude Opus 4.8、Gemini 3.5，中美AI三足鼎立谁主沉浮？022026年6月AI行业全景：从百模大战到Agent元年，这30天发生了什么？03【AI】2026 年具身智能模型和世界模型总结042026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf05Claude Code、Codex、Cursor三分天下：2026年AI编程Agent生态全景剖析06GitHub 镜像站点07【AI总结】2026年6月 主流国内外大模型总结08AI科技热点日报 | 2026年6月1日09AI科技热点日报 | 2026年6月22日10飞书长连接_事件订阅（接收消息，审批任务状态变更）