devbox
酷酷是懒虫
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【软件工具】如何使用 Jenkins 构建并部署一个 WAR 包到相应的服务器上

作者：酷酷是懒虫 | 2024-08-06 08:00:22

赞

踩

【软件工具】如何使用 Jenkins 构建并部署一个 WAR 包到相应的服务器上

如何使用 Jenkins 构建并部署一个 WAR 包到相应的服务器上

一、使用 Jenkins 构建并部署一个 WAR 包到相应的服务器上

使用 Jenkins 构建并部署一个 WAR 包到相应的服务器上，可以通过在 Jenkinsfile 中定义一系列步骤来实现。假设你需要在构建完成后将 WAR 文件复制到远程服务器，并执行相应的启动和停止命令，以下是一个示例 Jenkinsfile，可以帮助你实现这个流程。

示例 Jenkinsfile

pipeline {
    agent any

    environment {
        REMOTE_USER = 'your-remote-user'        // 远程服务器用户名
        REMOTE_HOST = 'your-remote-host'        // 远程服务器地址
        REMOTE_DIR = '/path/to/remote/dir'      // 远程服务器上的目标目录
        WAR_FILE = 'your-application.war'       // WAR 文件名称
        SSH_KEY = credentials('your-ssh-key-id') // Jenkins 中存储的 SSH 密钥凭证 ID
    }

    stages {
        stage('Build') {
            steps {
                // 假设你使用 Maven 构建 WAR 包
                sh 'mvn clean package'
            }
        }

        stage('Deploy') {
            steps {
                script {
                    // 将 WAR 包上传到远程服务器
                    sshagent(['your-ssh-key-id']) {
                        sh """
                            scp -o StrictHostKeyChecking=no target/${WAR_FILE} ${REMOTE_USER}@${REMOTE_HOST}:${REMOTE_DIR}
                        """
                    }
                }
            }
        }

        stage('Stop Server') {
            steps {
                script {
                    // 停止远程服务器上的应用程序
                    sshagent(['your-ssh-key-id']) {
                        sh """
                            ssh -o StrictHostKeyChecking=no ${REMOTE_USER}@${REMOTE_HOST} 'bash -c "cd ${REMOTE_DIR} && ./stop.sh"'
                        """
                    }
                }
            }
        }

        stage('Start Server') {
            steps {
                script {
                    // 启动远程服务器上的应用程序
                    sshagent(['your-ssh-key-id']) {
                        sh """
                            ssh -o StrictHostKeyChecking=no ${REMOTE_USER}@${REMOTE_HOST} 'bash -c "cd ${REMOTE_DIR} && ./start.sh"'
                        """
                    }
                }
            }
        }
    }

    post {
        always {
            // 清理工作或发送通知
            echo 'Pipeline finished'
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66

详细解释

  1. 定义环境变量：

    • REMOTE_USER：远程服务器的用户名。
    • REMOTE_HOST：远程服务器的地址。
    • REMOTE_DIR：远程服务器上的目标目录。
    • WAR_FILE：构建生成的 WAR 文件名称。
    • SSH_KEY：Jenkins 中存储的 SSH 密钥凭证 ID，用于安全连接远程服务器。

  2. 构建阶段：

    • 使用 Maven 构建项目，生成 WAR 包。

  3. 部署阶段：

    • 使用 scp 命令将构建生成的 WAR 文件上传到远程服务器的指定目录。这里使用 sshagent 插件进行 SSH 密钥管理，确保安全的 SSH 连接。

  4. 停止服务器阶段：

    • 使用 ssh 命令连接到远程服务器，并执行停止命令脚本 stop.sh。

  5. 启动服务器阶段：

    • 使用 ssh 命令连接到远程服务器，并执行启动命令脚本 start.sh。

  6. 后期处理：

    • 在 post 块中定义一些后续操作，如清理工作或发送通知。

准备工作

  • 安装 SSH 插件：确保 Jenkins 已安装 SSH 插件（如 SSH Agent Plugin）。
  • 配置 SSH 凭证：在 Jenkins 凭证管理中配置用于连接远程服务器的 SSH 密钥，并获取相应的凭证 ID。
  • 远程脚本：确保远程服务器上存在 stop.sh 和 start.sh 脚本，用于管理应用程序的启动和停止。

注意事项

  • 确保 Jenkins 服务器可以通过 SSH 连接到远程服务器，并且具有足够的权限执行相关命令。
  • 调试和测试 Jenkinsfile 时，建议逐步执行每个阶段，确保每一步都按预期工作。

通过这种方式，你可以实现从构建、部署到启动和停止应用程序的完整自动化流程，提高部署效率和可靠性。

二、在 Jenkins 中，构建生成的 WAR 包通常存放在项目的工作空间（workspace）目录下

在 Jenkins 中，构建生成的 WAR 包通常存放在项目的工作空间（workspace）目录下。具体路径取决于你的构建配置和工具（如 Maven、Gradle 等）的输出目录设置。

以下是一个常见的例子，假设你使用的是 Maven 构建工具：

Maven 构建项目

当你使用 Maven 构建项目并生成 WAR 包时，WAR 文件通常会被放置在项目的 target 目录中。

假设你的 Maven 项目结构如下：

my-project/
  ├── src/
  ├── pom.xml
  └── target/
       └── my-application.war

  • 1
  • 2
  • 3
  • 4
  • 5

Jenkins 构建过程

在 Jenkins 中，当你配置一个构建任务（Job）并执行构建时，Jenkins 会为该任务创建一个工作空间目录，构建过程将在这个目录中进行。

  1. 工作空间目录：工作空间目录的路径通常是：

    $JENKINS_HOME/workspace/<job-name>

    • 1

    其中 $JENKINS_HOME 是 Jenkins 的安装目录，<job-name> 是 Jenkins 任务的名称。

  2. 构建输出目录：如果你使用 Maven 构建项目，构建输出目录（包含 WAR 包）的路径通常是：

    $JENKINS_HOME/workspace/<job-name>/target/my-application.war

    • 1

示例 Jenkinsfile

以下是一个示例 Jenkinsfile，它展示了如何在构建完成后将 WAR 包复制到远程服务器，并执行启停命令。

pipeline {
    agent any

    environment {
        REMOTE_USER = 'your-remote-user'        // 远程服务器用户名
        REMOTE_HOST = 'your-remote-host'        // 远程服务器地址
        REMOTE_DIR = '/path/to/remote/dir'      // 远程服务器上的目标目录
        WAR_FILE = 'my-application.war'         // WAR 文件名称
        SSH_KEY = credentials('your-ssh-key-id') // Jenkins 中存储的 SSH 密钥凭证 ID
    }

    stages {
        stage('Build') {
            steps {
                // 假设你使用 Maven 构建 WAR 包
                sh 'mvn clean package'
            }
        }

        stage('Deploy') {
            steps {
                script {
                    // 将 WAR 包上传到远程服务器
                    sshagent(['your-ssh-key-id']) {
                        sh """
                            scp -o StrictHostKeyChecking=no target/${WAR_FILE} ${REMOTE_USER}@${REMOTE_HOST}:${REMOTE_DIR}
                        """
                    }
                }
            }
        }

        stage('Stop Server') {
            steps {
                script {
                    // 停止远程服务器上的应用程序
                    sshagent(['your-ssh-key-id']) {
                        sh """
                            ssh -o StrictHostKeyChecking=no ${REMOTE_USER}@${REMOTE_HOST} 'bash -c "cd ${REMOTE_DIR} && ./stop.sh"'
                        """
                    }
                }
            }
        }

        stage('Start Server') {
            steps {
                script {
                    // 启动远程服务器上的应用程序
                    sshagent(['your-ssh-key-id']) {
                        sh """
                            ssh -o StrictHostKeyChecking=no ${REMOTE_USER}@${REMOTE_HOST} 'bash -c "cd ${REMOTE_DIR} && ./start.sh"'
                        """
                    }
                }
            }
        }
    }

    post {
        always {
            // 清理工作或发送通知
            echo 'Pipeline finished'
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66

关键点

  1. 构建阶段：

    • 使用 Maven 构建项目并生成 WAR 包，生成的 WAR 包位于 target/ 目录下。

  2. 部署阶段：

    • 使用 scp 命令将 target/ 目录中的 WAR 包上传到远程服务器。

  3. 停止和启动服务器阶段：

    • 使用 ssh 命令连接到远程服务器，并执行停止和启动脚本。

确认 WAR 包位置

在你的 Jenkins 工作空间中，你可以通过以下方式确认生成的 WAR 包位置：

  1. 通过 Jenkins Web UI：

    • 在 Jenkins 任务的控制台输出中，查找 Maven 构建的输出日志，确认 WAR 包生成路径。

  2. 通过脚本输出：

    • 在 Jenkinsfile 中添加构建后检查命令，确认 WAR 包位置，例如：
      stage('Check WAR Location') {
    steps {
        sh 'ls -l target/'
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5

通过这些步骤和示例，你可以确认 WAR 包的生成位置，并将其部署到远程服务器上，确保应用程序的自动化构建和部署流程顺利进行。

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号