Jenkins 自动构建 搞起来

作为程序员，自动化构建、测试与部署是提升开发效率的核心手段之一，而Jenkins正是实现这一目标的业界主流工具。本文将从Jenkins的基础概念出发，逐步深入到环境搭建、核心功能配置、实战案例实现，全程搭配详细的操作步骤与可直接复用的代码示例，帮助你从入门到熟练掌握Jenkins的实践技巧。

一、Jenkins核心概念入门

在开始实操前，先明确几个Jenkins的核心术语，避免后续配置时产生困惑：

• Jenkins Master：核心控制节点，负责管理任务配置、调度构建任务、展示构建结果。通常我们操作的Jenkins界面就是Master节点提供的。

• Jenkins Agent：代理节点，用于执行Master分配的构建任务（如编译代码、运行测试、部署应用）。当构建任务较多时，可通过Agent节点实现负载均衡，避免Master节点压力过大。

• Job/项目：Jenkins的核心操作单元，包含了构建任务的所有配置（如源码地址、构建步骤、测试命令、部署脚本等）。常见的项目类型有"自由风格项目""流水线项目（Pipeline）"等，其中Pipeline是企业级实践的首选。

• 插件（Plugin）：Jenkins的功能扩展组件，通过安装不同的插件可实现源码拉取（如Git插件）、构建工具集成（如Maven插件）、部署工具集成（如Docker插件）等功能。

• 构建触发器（Build Trigger）：触发项目构建的条件，如手动触发、代码提交触发（Git WebHook）、定时触发、其他项目构建完成后触发等。

• 构建步骤（Build Step）：项目构建的具体执行动作，如执行Shell命令、运行Maven命令、调用Python脚本等。

• 构建后操作（Post-build Action）：构建完成后的后续处理，如归档构建产物、发送构建结果邮件、部署到服务器等。

二、Jenkins环境搭建（详细步骤）

Jenkins基于Java开发，因此运行前需先安装Java环境。本节将以"CentOS 7+Java 11+Jenkins 2.401"为例，讲解完整的搭建流程，Windows环境搭建思路类似，仅需替换对应命令。

2.1 前置条件：安装Java环境

Jenkins 2.357及以上版本要求Java 11或17，此处选择Java 11：

# 1. 检查系统是否已安装Java
java -version

# 2. 若未安装，通过YUM安装OpenJDK 11
yum install -y java-11-openjdk-devel

# 3. 验证安装结果（出现版本信息则说明安装成功）
java -version
# 预期输出：openjdk version "11.0.20" 2023-07-18 LTS
# OpenJDK Runtime Environment (Red_Hat-11.0.20.0.8-1.el7_9)
# OpenJDK 64-Bit Server VM (Red_Hat-11.0.20.0.8-1.el7_9, mixed mode, sharing)

2.2 安装Jenkins

# 1. 导入Jenkins官方GPG密钥
rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io-2023.key

# 2. 添加Jenkins YUM源到系统
cat > /etc/yum.repos.d/jenkins.repo << EOF
[jenkins]
name=Jenkins
baseurl=https://pkg.jenkins.io/redhat-stable
enabled=1
gpgcheck=1
EOF

# 3. 安装Jenkins
yum install -y jenkins

# 4. 启动Jenkins服务并设置开机自启
systemctl start jenkins
systemctl enable jenkins

# 5. 检查Jenkins服务状态（确保状态为active）
systemctl status jenkins

# 6. 开放Jenkins默认端口8080（若开启了防火墙）
firewall-cmd --permanent --add-port=8080/tcp
firewall-cmd --reload

2.3 初始化Jenkins配置

1. 访问Jenkins界面：在浏览器中输入 http://服务器IP:8080

2. 解锁Jenkins：页面提示需要输入初始管理员密码，执行以下命令获取：

cat /var/lib/jenkins/secrets/initialAdminPassword

3. 安装推荐插件：输入密码后，选择"Install suggested plugins"，等待插件安装完成（若部分插件安装失败，可后续在插件管理中手动安装）。

4. 创建管理员用户：插件安装完成后，设置管理员账号、密码、邮箱（如admin/admin123，实际生产环境需设置复杂密码）。

5. 配置Jenkins URL：默认使用8080端口，直接点击"Save and Finish"，完成初始化。

2.4 必备插件安装

初始化时安装的推荐插件可能不足以满足实战需求，需补充安装以下核心插件：

1. 进入插件管理：Jenkins首页 → 系统管理 → 插件管理 → 可选插件

2. 搜索并安装以下插件（勾选后点击"直接安装"，安装完成后重启Jenkins）：

   Git Plugin：支持从Git仓库拉取源码

3. Maven Integration Plugin：支持Maven构建Java项目

4. Pipeline Plugin：支持流水线项目（核心插件）

5. Docker Plugin：支持Docker相关操作

6. Publish Over SSH：支持通过SSH部署项目到远程服务器

7. Email Extension Plugin：增强邮件通知功能

三、Jenkins核心配置（基础必备）

在创建项目前，需先完成基础工具配置（如JDK、Maven、Git）和全局凭据配置，避免后续项目中重复配置。

3.1 全局工具配置（JDK、Maven、Git）

进入路径：Jenkins首页 → 系统管理 → 全局工具配置

3.1.1 配置JDK

1. 取消"Install automatically"（使用系统已安装的JDK）

2. 名称：自定义（如JDK11）

3. JAVA_HOME：输入系统中JDK的安装路径，可通过 echo $JAVA_HOME 获取（通常为 /usr/lib/jvm/java-11-openjdk）

4. 点击"保存"暂存配置（后续配置完Maven和Git后统一保存）

3.1.2 配置Maven

若系统未安装Maven，先执行以下命令安装：

# 下载Maven 3.8.8（可替换为最新版本）
wget https://archive.apache.org/dist/maven/maven-3/3.8.8/binaries/apache-maven-3.8.8-bin.tar.gz

# 解压到/usr/local目录
tar -zxvf apache-maven-3.8.8-bin.tar.gz -C /usr/local/

# 重命名（方便后续使用）
mv /usr/local/apache-maven-3.8.8 /usr/local/maven

# 配置Maven环境变量
cat > /etc/profile.d/maven.sh << EOF
export M2_HOME=/usr/local/maven
export PATH=\$PATH:\$M2_HOME/bin
EOF

# 生效环境变量
source /etc/profile.d/maven.sh

# 验证Maven安装
mvn -v

然后在Jenkins中配置Maven：

1. 取消"Install automatically"

2. 名称：自定义（如Maven3.8.8）

3. MAVEN_HOME：输入Maven安装路径（/usr/local/maven）

3.1.3 配置Git

系统通常已预装Git，若未安装执行 yum install -y git，然后在Jenkins中配置：

1. 名称：自定义（如Git）

2. Path to Git executable：输入Git的安装路径（可通过 which git 获取，通常为 /usr/bin/git）

3. 点击"保存"，完成全局工具配置。

3.2 全局凭据配置

凭据用于存储源码仓库（如GitHub、GitLab）的账号密码、服务器SSH密钥等敏感信息，避免在项目配置中明文填写。常见的凭据类型有"Username with password"（账号密码）和"SSH Username with private key"（SSH密钥）。

3.2.1 配置Git仓库账号密码凭据（以GitHub为例）

1. 进入凭据管理：Jenkins首页 → 系统管理 → 凭据 → 系统 → 全局凭据 → 添加凭据

2. 选择类型：Username with password

3. Username：GitHub账号（如your-github-username）

4. Password：GitHub密码或个人访问令牌（若开启了2FA，需使用个人访问令牌，在GitHub → Settings → Developer settings → Personal access tokens生成，勾选repo权限）

5. ID：自定义（如github-cred），后续项目中会用到

6. 描述：可选（如GitHub账号凭据）

7. 点击"确定"，完成配置。

3.2.2 配置SSH服务器凭据（用于部署项目）

若需将构建后的项目部署到远程服务器，需配置SSH凭据：

1. 在Jenkins服务器生成SSH密钥对（若已存在可跳过）：

2. 将公钥复制到目标部署服务器（假设部署服务器IP为192.168.1.100，用户名为root）：

3. 在Jenkins中添加SSH凭据：

   选择类型：SSH Username with private key

4. Username：部署服务器的用户名（如root）

5. Private Key：选择"Enter directly"，点击"Add"，粘贴Jenkins服务器的私钥内容（cat ~/.ssh/id_rsa 获取）

6. ID：自定义（如deploy-server-ssh）

7. 点击"确定"，完成配置。

四、Jenkins实战案例（从构建到部署）

本节将通过两个核心实战案例，覆盖"Java Maven项目构建部署"和"前端Vue项目构建部署"，全程使用流水线（Pipeline）方式配置（企业级首选，支持代码化管理构建流程）。

案例1：Java Maven项目构建与SSH部署

假设我们有一个Java Maven项目，源码托管在GitHub，需实现"拉取源码 → 编译构建 → 运行单元测试 → 打包成Jar包 → 部署到远程服务器"的完整流程。

4.1.1 准备工作

• GitHub仓库地址：如 https://github.com/your-username/java-demo-project.git（项目根目录需包含pom.xml文件）

• 部署服务器：192.168.1.100，部署路径为 /opt/java-app

• 项目启动脚本：在部署服务器的 /opt/java-app 目录下创建 start.sh 脚本（用于启动Jar包）

# 部署服务器上创建启动脚本 start.sh
cat > /opt/java-app/start.sh << EOF
#!/bin/bash
# 停止已运行的Java进程
PID=\$(ps -ef | grep java-demo-1.0-SNAPSHOT.jar | grep -v grep | awk '{print \$2}')
if [ -n "\$PID" ]; then
  kill -9 \$PID
  echo "已停止进程：\$PID"
fi

# 启动新的Jar包（后台运行，输出日志到app.log）
nohup java -jar java-demo-1.0-SNAPSHOT.jar > app.log 2>&1 &
echo "项目启动成功，日志路径：/opt/java-app/app.log"
EOF

# 给脚本添加执行权限
chmod +x /opt/java-app/start.sh

4.1.2 创建Pipeline项目

1. Jenkins首页 → 新建Item → 输入项目名称（如java-demo-pipeline） → 选择"流水线" → 点击"确定"

2. 配置项目基础信息：

   描述：可选（如Java项目构建部署流水线）

3. 丢弃旧的构建：勾选，设置"保持构建的最大个数"为10（避免构建记录过多占用磁盘）

4. 配置源码管理：

   选择"Git"

5. Repository URL：输入GitHub仓库地址（如 https://github.com/your-username/java-demo-project.git）

6. Credentials：选择之前配置的GitHub凭据（如github-cred）

7. Branch Specifier：指定构建的分支（如 */main）

8. 配置构建触发器（可选，根据需求设置）：

   手动触发：默认支持，无需额外配置

9. 代码提交触发（WebHook）：勾选"GitHub hook trigger for GITScm polling"，然后在GitHub仓库中配置WebHook（后续讲解）

10. 定时触发：勾选"Build periodically"，输入 cron 表达式（如 H/30 * * * * 表示每30分钟构建一次）

11. 配置流水线脚本：

    选择"Pipeline script"（也可选择"Pipeline script from SCM"，将Jenkinsfile放在项目源码中，实现"流水线即代码"）

12. 在脚本框中输入以下Pipeline代码（包含详细注释）：

pipeline {
    // 指定构建节点（master表示在主节点执行，若有Agent节点可指定Agent名称）
    agent any
    
    // 定义环境变量（方便后续复用）
    environment {
        // 部署服务器信息
        DEPLOY_SERVER = '192.168.1.100'
        DEPLOY_USER = 'root'
        DEPLOY_PATH = '/opt/java-app'
        // Jar包名称（需与pom.xml中配置的artifactId和version一致）
        JAR_NAME = 'java-demo-1.0-SNAPSHOT.jar'
    }
    
    // 工具配置（引用全局工具配置中定义的JDK和Maven）
    tools {
        jdk 'JDK11'
        maven 'Maven3.8.8'
    }
    
    // 构建流程（分阶段执行）
    stages {
        // 阶段1：拉取源码（由源码管理部分自动完成，此处仅作日志输出）
        stage('拉取源码') {
            steps {
                echo "===== 开始拉取GitHub源码 ====="
                echo "仓库地址：${env.GIT_URL}"
                echo "构建分支：${env.GIT_BRANCH}"
                echo "===== 源码拉取完成 ====="
            }
        }
        
        // 阶段2：编译构建与单元测试
        stage('编译构建与测试') {
            steps {
                echo "===== 开始编译构建 ====="
                // 执行Maven命令：清理之前的构建产物、编译、运行单元测试、打包
                sh 'mvn clean compile test package -Dmaven.test.skip=false'
                echo "===== 编译构建与测试完成 ====="
            }
            // 构建后操作：归档测试报告（若项目有单元测试）
            post {
                always {
                    junit '**/target/surefire-reports/*.xml' // 归档JUnit测试报告
                }
            }
        }
        
        // 阶段3：归档构建产物
        stage('归档产物') {
            steps {
                echo "===== 开始归档构建产物 ====="
                // 归档Jar包（后续可在构建记录中下载）
                archiveArtifacts artifacts: "target/${JAR_NAME}", fingerprint: true
                echo "===== 产物归档完成 ====="
            }
        }
        
        // 阶段4：部署到远程服务器
        stage('部署到服务器') {
            steps {
                echo "===== 开始部署到服务器 ${DEPLOY_SERVER} ====="
                // 通过SSH将Jar包上传到部署服务器的指定路径
                sshPublisher(publishers: [sshPublisherDesc(
                    configName: 'deploy-server-ssh', // 引用之前配置的SSH凭据ID
                    transfers: [sshTransfer(
                        sourceFiles: "target/${JAR_NAME}", // 本地Jar包路径
                        remoteDirectory: DEPLOY_PATH, // 远程服务器目标路径
                        cleanRemote: false, // 不清理远程路径下的其他文件
                        execCommand: "${DEPLOY_PATH}/start.sh" // 上传完成后执行启动脚本
                    )]
                )])
                echo "===== 部署完成 ====="
            }
        }
    }
    
    // 整个流水线构建完成后的操作（发送邮件通知）
    post {
        // 构建成功时发送邮件
        success {
            echo "===== 构建成功，发送通知邮件 ====="
            emailext(
                subject: "Jenkins构建通知：${env.JOB_NAME} 构建成功",
                body: """
                    项目名称：${env.JOB_NAME}
                    构建编号：${env.BUILD_NUMBER}
                    构建状态：成功
                    仓库地址：${env.GIT_URL}
                    构建分支：${env.GIT_BRANCH}
                    构建日志：${env.BUILD_URL}console
                    产物下载：${env.BUILD_URL}artifact/target/${JAR_NAME}
                """,
                to: 'your-email@example.com' // 接收邮件的地址
            )
        }
        // 构建失败时发送邮件
        failure {
            echo "===== 构建失败，发送通知邮件 ====="
            emailext(
                subject: "Jenkins构建通知：${env.JOB_NAME} 构建失败",
                body: """
                    项目名称：${env.JOB_NAME}
                    构建编号：${env.BUILD_NUMBER}
                    构建状态：失败
                    仓库地址：${env.GIT_URL}
                    构建分支：${env.GIT_BRANCH}
                    构建日志：${env.BUILD_URL}console
                """,
                to: 'your-email@example.com'
            )
        }
    }
}

6. 点击"保存"，完成项目配置。

4.1.3 执行构建与验证

1. 手动触发构建：进入项目页面 → 点击"立即构建"

2. 查看构建日志：点击构建历史中的最新构建编号（如#1） → 点击"控制台输出"，查看构建过程中的日志（若出现错误，可根据日志排查问题）。

3. 验证部署结果：登录部署服务器（192.168.1.100），执行以下命令：

# 查看Java进程是否启动
ps -ef | grep java-demo-1.0-SNAPSHOT.jar

# 查看项目日志
tail -f /opt/java-app/app.log

4.1.4 配置GitHub WebHook（代码提交自动触发构建）

若需实现"代码提交到GitHub后，Jenkins自动触发构建"，需配置GitHub WebHook：

1. 获取Jenkins WebHook地址：格式为 http://Jenkins服务器IP:8080/github-webhook/（注意结尾的斜杠不能省略）

2. 进入GitHub仓库 → Settings → Webhooks → Add webhook

3. 填写WebHook信息：

   Payload URL：输入Jenkins WebHook地址（如 http://192.168.1.200:8080/github-webhook/）

4. Content type：选择 application/json

5. Which events would you like to trigger this webhook?：选择"Just the push event."（仅代码提交时触发）

6. Active：勾选

7. 点击"Add webhook"，完成配置。此时修改本地代码并提交到GitHub，Jenkins会自动触发项目构建。

案例2：前端Vue项目构建与Nginx部署

前端项目的构建流程通常为"拉取源码 → 安装依赖 → 打包构建 → 部署到Nginx服务器"，以下是完整的Pipeline配置。

4.2.1 准备工作

• GitHub仓库地址：如 https://github.com/your-username/vue-demo-project.git（项目根目录包含package.json文件）

• 部署服务器：192.168.1.100，已安装Nginx，Nginx网站根目录为 /usr/share/nginx/html/vue-app

• 在Jenkins服务器安装Node.js（用于前端依赖安装和打包）：

# 安装Node.js 16（前端项目常用版本）
curl -fsSL https://deb.nodesource.com/setup_16.x | bash -
yum install -y nodejs

# 验证Node.js和npm安装
node -v
npm -v

# 安装cnpm（国内镜像，加速依赖安装）
npm install -g cnpm --registry=https://registry.npmmirror.com

在Jenkins全局工具配置中添加Node.js配置：

1. Jenkins首页 → 系统管理 → 全局工具配置 → NodeJS → 点击"Add NodeJS"

2. 名称：自定义（如NodeJS16）

3. 取消"Install automatically"，输入NodeJS安装路径（通过 which node 获取，通常为 /usr/bin/node）

4. 点击"保存"。

4.2.2 创建Vue项目Pipeline

1. Jenkins首页 → 新建Item → 输入项目名称（如vue-demo-pipeline） → 选择"流水线" → 点击"确定"

2. 配置源码管理（同Java项目，选择GitHub仓库和对应凭据）

3. 配置构建触发器（可选，如WebHook自动触发）

4. 配置流水线脚本：

pipeline {
    agent any
    
    environment {
        DEPLOY_SERVER = '192.168.1.100'
        DEPLOY_USER = 'root'
        // Nginx网站根目录（前端打包产物部署路径）
        DEPLOY_PATH = '/usr/share/nginx/html/vue-app'
        // 前端打包产物目录（Vue项目打包后默认生成dist目录）
        BUILD_DIR = 'dist'
    }
    
    tools {
        git 'Git'
        nodejs 'NodeJS16' // 引用全局工具配置中的NodeJS
    }
    
    stages {
        stage('拉取源码') {
            steps {
                echo "===== 开始拉取GitHub源码 ====="
                echo "仓库地址：${env.GIT_URL}"
                echo "构建分支：${env.GIT_BRANCH}"
                echo "===== 源码拉取完成 ====="
            }
        }
        
        stage('安装依赖') {
            steps {
                echo "===== 开始安装前端依赖 ====="
                // 进入项目根目录（默认已在根目录，可省略）
                // cd ${WORKSPACE}
                // 使用cnpm安装依赖（加速国内环境）
                sh 'cnpm install'
                echo "===== 依赖安装完成 ====="
            }
        }
        
        stage('打包构建') {
            steps {
                echo "===== 开始打包构建 ====="
                // 执行npm打包命令（若项目package.json中配置的打包命令为build）
                sh 'npm run build'
                echo "===== 打包构建完成 ====="
            }
            post {
                always {
                    // 归档打包产物
                    archiveArtifacts artifacts: "${BUILD_DIR}/**", fingerprint: true
                }
            }
        }
        
        stage('部署到Nginx') {
            steps {
                echo "===== 开始部署到Nginx服务器 ====="
                sshPublisher(publishers: [sshPublisherDesc(
                    configName: 'deploy-server-ssh',
                    transfers: [sshTransfer(
                        sourceFiles: "${BUILD_DIR}/**", // 本地打包产物目录
                        remoteDirectory: DEPLOY_PATH,
                        cleanRemote: true, // 部署前清理远程路径下的旧文件（避免残留）
                        execCommand: "chmod -R 755 ${DEPLOY_PATH} && systemctl restart nginx" // 授权并重启Nginx
                    )]
                )])
                echo "===== 部署完成 ====="
            }
        }
    }
    
    post {
        success {
            emailext(
                subject: "Jenkins构建通知：${env.JOB_NAME} 构建成功",
                body: """
                    项目名称：${env.JOB_NAME}
                    构建编号：${env.BUILD_NUMBER}
                    构建状态：成功
                    访问地址：http://${DEPLOY_SERVER}/vue-app
                    构建日志：${env.BUILD_URL}console
                """,
                to: 'your-email@example.com'
            )
        }
        failure {
            emailext(
                subject: "Jenkins构建通知：${env.JOB_NAME} 构建失败",
                body: """
                    项目名称：${env.JOB_NAME}
                    构建编号：${env.BUILD_NUMBER}
                    构建状态：失败
                    构建日志：${env.BUILD_URL}console
                """,
                to: 'your-email@example.com'
            )
        }
    }
}

5. 点击"保存"，手动触发构建，构建完成后访问 http://192.168.1.100/vue-app 即可查看前端项目。

五、Jenkins进阶技巧（实战必备）

5.1 流水线脚本优化（Jenkinsfile放在项目中）

前面的案例中，流水线脚本直接写在Jenkins项目配置中，不利于版本控制和团队协作。推荐将Jenkinsfile放在项目源码根目录，实现"流水线即代码"：

1. 在项目源码根目录创建Jenkinsfile，将之前的Pipeline脚本复制到文件中并保存。

2. 修改Jenkins项目配置：

   进入项目配置 → 流水线 → 选择"Pipeline script from SCM"

3. SCM：选择"Git"

4. Repository URL和Credentials：同之前配置

5. Script Path：输入Jenkinsfile（默认在项目根目录，若放在子目录需指定路径，如 docs/Jenkinsfile）

6. 点击"保存"，后续构建时Jenkins会自动从源码中读取Jenkinsfile执行。

5.2 Agent节点配置（分布式构建）

当构建任务较多时，可添加Agent节点分担Master节点压力：

1. 准备Agent节点服务器：安装Java环境（同Master节点），并确保Agent节点能SSH连接到Master节点。

2. 在Master节点中添加Agent：

   Jenkins首页 → 系统管理 → 节点管理 → 新建节点

3. 输入节点名称（如agent-1） → 选择"固定节点" → 点击"确定"

4. 配置节点信息：

   远程根目录：Agent节点中Jenkins的工作目录（如 /var/lib/jenkins-agent）

5. 标签：自定义标签（如 java-agent，后续在Pipeline中通过标签指定Agent）

6. 启动方式：选择"通过SSH启动代理"

7. 主机：Agent节点IP（如192.168.1.101）

8. 凭据：选择Agent节点的SSH凭据（需提前在全局凭据中配置）

9. 主机密钥验证策略：选择"不验证"（测试环境，生产环境建议选择"手动信任"）

10. 点击"保存"，然后点击节点名称 → 点击"启动代理"，若状态变为"在线"，说明Agent节点配置成功。

11. 在Pipeline中指定Agent节点：修改Pipeline脚本的agent部分：

pipeline {
    agent {
        label 'java-agent' // 指定带有java-agent标签的Agent节点执行构建
    }
    // 其余配置不变...
}

5.3 常见问题排查技巧

• 插件安装失败：进入插件管理 → 高级 → 更换Jenkins插件源（如国内镜像源 https://mirrors.tuna.tsinghua.edu.cn/jenkins/plugins/） → 点击"提交"后重新安装。

• 源码拉取失败 ：检查GitHub凭据是否正确、Jenkins服务器能否访问GitHub（可在Jenkins服务器执行 git clone 仓库地址 测试）、仓库地址是否错误。

• 构建脚本执行失败：查看控制台输出日志，定位错误行（如Maven命令失败可能是依赖缺失，前端打包失败可能是Node.js版本不兼容）。

• SSH部署失败 ：检查SSH凭据是否正确、Jenkins服务器能否SSH连接到部署服务器（执行 ssh root@192.168.1.100 测试）、部署路径是否存在且有写入权限。

六、总结

本文从Jenkins的基础概念出发，逐步讲解了环境搭建、核心配置、实战案例（Java和前端项目）以及进阶技巧，全程搭配详细的操作步骤和可复用的代码示例。通过本文的学习，你应该能够独立完成Jenkins的部署与项目构建部署工作。

Jenkins的功能远不止于此，后续还可以深入学习Docker集成（通过Docker容器构建和部署项目）、Kubernetes集成（将项目部署到K8s集群）、多环境部署（开发、测试、生产环境）等高级用法。建议在实际项目中多实践，逐步积累经验，充分发挥Jenkins在自动化运维中的价值。