使用中间件自动化部署java应用

飞的肖2025-01-16 3:05

为了实现你在 IntelliJ IDEA 中打包项目并通过工具推送到两个 Docker 服务器（172.168.0.1 和 172.168.0.12），并在推送后自动或手动重启容器，我们可以按照以下步骤进行操作：

  1. 在 IntelliJ IDEA 中配置 Maven 或 Gradle 打包：

    • 如果你使用的是 Maven，确保 pom.xml 文件中有正确的构建配置。
    • 如果你使用的是 Gradle，确保 build.gradle 文件中有正确的构建配置。

  2. 构建 Docker 镜像：

    • 创建一个 Dockerfile 文件来定义如何构建你的应用程序镜像。

  3. 配置 Docker 客户端：

    • 在本地机器上安装 Docker 并配置好与远程 Docker 服务器的连接。

  4. 编写脚本来自动化整个流程：

    • 使用 Bash 脚本或其他脚本语言来自动化构建、推送和重启容器的过程。

  5. 设置中间件：

    • 可以使用 Jenkins、GitLab CI/CD、Ansible 等工具来管理自动化流程。

下面是一个详细的示例，假设你使用的是 Maven 和 Docker，并且使用 Jenkins 来管理自动化流程。

1. 配置 Maven 打包

确保 pom.xml 文件中包含以下内容：

xml

XML 复制代码 
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>my-application</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

2. 创建 Dockerfile

创建一个 Dockerfile 文件：

XML 复制代码 
# 使用官方的 Java 基础镜像
FROM openjdk:11-jre-slim

# 设置工作目录
WORKDIR /app

# 复制构建好的 jar 文件到镜像中
COPY target/my-application-1.0-SNAPSHOT.jar my-application.jar

# 暴露应用程序的端口
EXPOSE 8080

# 运行应用程序
ENTRYPOINT ["java", "-jar", "my-application.jar"]
复制代码 
ENTRYPOINT ["java", "-jar", "my-application.jar"]

3. 配置 Docker 客户端

确保你的本地机器上有 Docker 安装并且可以连接到远程 Docker 服务器。你可以通过 SSH 连接到远程 Docker 服务器并配置 Docker 守护进程监听 TCP 端口。

编辑 /etc/docker/daemon.json 文件：

bash

bash 复制代码 
{
  "hosts": ["unix:///var/run/docker.sock", "tcp://0.0.0.0:2375"]
}

然后重启 Docker 服务：

bash

bash 复制代码 
sudo systemctl restart docker

4. 编写 Jenkins Pipeline

在 Jenkins 中创建一个新的 Pipeline 项目，并添加以下 Groovy 脚本：

groovy

bash 复制代码 
pipeline {
    agent any

    stages {
        stage('Build') {
            steps {
                sh 'mvn clean package'
            }
        }

        stage('Build Docker Image') {
            steps {
                script {
                    def app = docker.build("my-application:${env.BUILD_ID}")
                    app.push("172.168.0.1:5000/my-application:${env.BUILD_ID}")
                    app.push("172.168.0.12:5000/my-application:${env.BUILD_ID}")
                }
            }
        }

        stage('Deploy to 172.168.0.1') {
            steps {
                script {
                    // 登录到第一个 Docker 服务器
                    sh 'ssh user@172.168.0.1 "docker pull 172.168.0.1:5000/my-application:${BUILD_ID} && docker stop my-application || true && docker rm my-application || true && docker run -d --name my-application -p 8080:8080 172.168.0.1:5000/my-application:${BUILD_ID}"'
                }
            }
        }

        stage('Deploy to 172.168.0.12') {
            steps {
                script {
                    // 登录到第二个 Docker 服务器
                    sh 'ssh user@172.168.0.12 "docker pull 172.168.0.12:5000/my-application:${BUILD_ID} && docker stop my-application || true && docker rm my-application || true && docker run -d --name my-application -p 8080:8080 172.168.0.12:5000/my-application:${BUILD_ID}"'
                }
            }
        }
    }
}

5. 设置中间件

在这个例子中，我们使用 Jenkins 来管理整个流程。Jenkins 可以自动触发构建过程，并在构建完成后自动执行部署和重启操作。

5.1 安装 Jenkins 插件

确保在 Jenkins 中安装了以下插件：

  • Git Plugin
  • Docker Pipeline Plugin
5.2 配置 Jenkins 凭证

在 Jenkins 中配置 SSH 凭证，以便 Jenkins 可以通过 SSH 访问远程 Docker 服务器。

6. 测试流程

  1. 提交代码到版本控制系统（如 Git）。
  2. 触发 Jenkins 构建（可以通过定时任务、手动触发或 Webhook 触发）。
  3. Jenkins 将会自动执行构建、打包、推送 Docker 镜像以及部署和重启容器的操作。

这样，你就完成了从 IntelliJ IDEA 到 Jenkins 自动化构建、打包、推送和部署 Docker 镜像的全过程。

另外一个案例介绍

使用中间件来管理和自动化 Docker 容器的部署和管理是一个很好的实践，可以帮助提高效率和一致性。我们将使用 Jenkins 作为中间件来管理 Docker 容器，并配置一个具体的案例。

案例概述

假设我们有一个简单的 Spring Boot 应用程序，我们需要将其打包成 Docker 镜像，并推送到两个 Docker 服务器（172.168.0.1 和 172.168.0.12）。然后在每个服务器上自动或手动重启容器。

步骤

  1. 准备项目代码
  2. 创建 Dockerfile
  3. 安装并配置 Jenkins
  4. 配置 Jenkins Pipeline
  5. 设置 Docker Hub 或私有仓库
  6. 测试整个流程

1. 准备项目代码

假设你已经有一个 Spring Boot 项目，以下是项目的目录结构：

my-spring-boot-app/
├── src/
│   └── ...
├── pom.xml
└── Dockerfile

2. 创建 Dockerfile

在项目根目录下创建一个 Dockerfile 文件：

# 使用官方的 Java 基础镜像
FROM openjdk:11-jre-slim

# 设置工作目录
WORKDIR /app

# 复制构建好的 jar 文件到镜像中
COPY target/my-spring-boot-app-1.0-SNAPSHOT.jar my-spring-boot-app.jar

# 暴露应用程序的端口
EXPOSE 8080

# 运行应用程序
ENTRYPOINT ["java", "-jar", "my-spring-boot-app.jar"]

3. 安装并配置 Jenkins

3.1 安装 Jenkins

你可以通过多种方式安装 Jenkins，这里以 Ubuntu 为例：

bash

bash 复制代码 
wget -q -O - https://pkg.jenkins.io/debian/jenkins.io.key | sudo apt-key add -
sudo sh -c 'echo deb http://pkg.jenkins.io/debian-stable binary/ > /etc/apt/sources.list.d/jenkins.list'
sudo apt-get update
sudo apt-get install jenkins
sudo systemctl start jenkins
sudo systemctl enable jenkins

访问 http://your_jenkins_server_ip_or_domain:8080 并完成初始设置。

3.2 安装必要的插件

在 Jenkins 管理界面中，导航到"Manage Jenkins" -> "Manage Plugins"，安装以下插件：

  • Git Plugin
  • Docker Pipeline Plugin
  • SSH Agent Plugin
3.3 配置 SSH 凭证
  1. 导航到"Manage Jenkins" -> "Manage Credentials"。
  2. 添加全局凭证：
    • 类型：SSH Username with private key
    • ID：jenkins-docker-server
    • Description：Credentials for accessing Docker servers
    • Username：user_on_docker_servers
    • Private Key：粘贴你的私钥内容

4. 配置 Jenkins Pipeline

4.1 创建一个新的 Pipeline 项目
  1. 在 Jenkins 主页点击"New Item"。
  2. 输入项目名称，选择"Pipeline"，然后点击"OK"。
4.2 编写 Jenkins Pipeline 脚本

在 Pipeline 项目的配置页面中，找到"Pipeline"部分，将以下 Groovy 脚本粘贴进去：

groovy

Groovy 复制代码 
pipeline {
    agent any

    environment {
        DOCKER_IMAGE_NAME = 'my-spring-boot-app'
        VERSION = "${env.BUILD_ID}"
        DOCKER_SERVER_1 = '172.168.0.1'
        DOCKER_SERVER_2 = '172.168.0.12'
        SSH_CREDENTIALS_ID = 'jenkins-docker-server'
    }

    stages {
        stage('Checkout') {
            steps {
                git url: 'https://github.com/yourusername/my-spring-boot-app.git', branch: 'main'
            }
        }

        stage('Build') {
            steps {
                sh 'mvn clean package'
            }
        }

        stage('Build Docker Image') {
            steps {
                script {
                    docker.build("${DOCKER_IMAGE_NAME}:${VERSION}")
                }
            }
        }

        stage('Push Docker Image to Server 1') {
            steps {
                sshagent([env.SSH_CREDENTIALS_ID]) {
                    sh """
                        docker save -o ${DOCKER_IMAGE_NAME}-${VERSION}.tar ${DOCKER_IMAGE_NAME}:${VERSION}
                        scp ${DOCKER_IMAGE_NAME}-${VERSION}.tar user@${DOCKER_SERVER_1}:/home/user/${DOCKER_IMAGE_NAME}-${VERSION}.tar
                        ssh user@${DOCKER_SERVER_1} "
                            docker load -i /home/user/${DOCKER_IMAGE_NAME}-${VERSION}.tar &&
                            docker stop ${DOCKER_IMAGE_NAME} || true &&
                            docker rm ${DOCKER_IMAGE_NAME} || true &&
                            docker run -d --name ${DOCKER_IMAGE_NAME} -p 8080:8080 ${DOCKER_IMAGE_NAME}:${VERSION}
                        "
                    """
                }
            }
        }

        stage('Push Docker Image to Server 2') {
            steps {
                sshagent([env.SSH_CREDENTIALS_ID]) {
                    sh """
                        docker save -o ${DOCKER_IMAGE_NAME}-${VERSION}.tar ${DOCKER_IMAGE_NAME}:${VERSION}
                        scp ${DOCKER_IMAGE_NAME}-${VERSION}.tar user@${DOCKER_SERVER_2}:/home/user/${DOCKER_IMAGE_NAME}-${VERSION}.tar
                        ssh user@${DOCKER_SERVER_2} "
                            docker load -i /home/user/${DOCKER_IMAGE_NAME}-${VERSION}.tar &&
                            docker stop ${DOCKER_IMAGE_NAME} || true &&
                            docker rm ${DOCKER_IMAGE_NAME} || true &&
                            docker run -d --name ${DOCKER_IMAGE_NAME} -p 8080:8080 ${DOCKER_IMAGE_NAME}:${VERSION}
                        "
                    """
                }
            }
        }
    }

    post {
        always {
            cleanWs()
        }
    }
}

5. 设置 Docker Hub 或私有仓库

在这个案例中，我们直接在 Jenkins 上构建和推送 Docker 镜像到远程服务器。如果你希望使用 Docker Hub 或私有仓库，可以进行相应的调整。

5.1 使用 Docker Hub
  1. 登录 Docker Hub 并创建一个仓库。
  2. 修改 Jenkins Pipeline 脚本中的推送步骤：

groovy

Groovy 复制代码 
stage('Push Docker Image to Docker Hub') {
    steps {
        script {
            docker.withRegistry('https://index.docker.io/v1/', 'docker-hub-credentials-id') {
                def app = docker.build("${env.DOCKER_IMAGE_NAME}:${env.VERSION}")
                app.push()
            }
        }
    }
}

确保在 Jenkins 中配置了 Docker Hub 的凭据。

6. 测试整个流程

  1. 提交代码到版本控制系统（如 Git）。
  2. 手动触发 Jenkins 构建（可以在 Jenkins 项目主页点击"Build Now"）。
  3. Jenkins 将会自动执行以下操作：
    • 从 Git 仓库拉取最新代码。
    • 构建 Maven 项目并生成 JAR 文件。
    • 构建 Docker 镜像。
    • 推送 Docker 镜像到两个 Docker 服务器。
    • 在每个服务器上停止并删除旧的容器，然后启动新的容器。

总结

通过上述步骤，我们成功地使用 Jenkins 作为中间件来管理和自动化 Docker 容器的部署和管理。Jenkins 自动化了从代码提交到应用部署的整个过程，提高了效率和一致性。

如果你有任何问题或需要进一步细化某个部分，请告诉我！

相关推荐
御坂100272 小时前
EasyExcel - 行合并策略（二级列表）
java·开发语言
程序员沉梦听雨3 小时前
【IDEA】快捷键篇
java·ide·intellij-idea
Q_27437851095 小时前
django基于Python的智能停车管理系统
java·数据库·python·django
兩尛6 小时前
maven高级（day15）
java·开发语言·maven
xiao--xin7 小时前
LeetCode100之搜索二维矩阵(46)--Java
java·算法·leetcode·二分查找
end_SJ7 小时前
c语言 --- 字符串
java·c语言·算法
zzyh1234567 小时前
spring cloud 负载均衡策略
java·spring cloud·负载均衡
涔溪7 小时前
JS二叉树是什么？二叉树的特性
java·javascript·数据结构
zzyh1234567 小时前
springcloud负载均衡原理
java·spring cloud·负载均衡
热门推荐
01玄机平台应急响应—webshell查杀02Dell服务器升级ubuntu 22.04失败解决03半导体应用系统一些小知识收集(strip&wafer mapping,EAP&scada)04年出货2亿台，只赚“辛苦钱”！又一家代工巨头押宝汽车电子05密码学原理技术-第六章-introduction to pulibc-key cryptography06优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间07[Docker]使用Docker部署常见的中间件08go下载依赖提示连接失败09渗透测试之SQLMAP工具详解 kali自带SQLmap解释 重点sqlmap --tamper 使用方式详解 搞完你就很nice了10(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明