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

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

在 IntelliJ IDEA 中配置 Maven 或 Gradle 打包：
- 如果你使用的是 Maven，确保 pom.xml 文件中有正确的构建配置。
- 如果你使用的是 Gradle，确保 build.gradle 文件中有正确的构建配置。
构建 Docker 镜像：
- 创建一个 Dockerfile 文件来定义如何构建你的应用程序镜像。
配置 Docker 客户端：
- 在本地机器上安装 Docker 并配置好与远程 Docker 服务器的连接。
编写脚本来自动化整个流程：
- 使用 Bash 脚本或其他脚本语言来自动化构建、推送和重启容器的过程。
设置中间件：
- 可以使用 Jenkins、GitLab CI/CD、Ansible 等工具来管理自动化流程。

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

1. 配置 Maven 打包

确保 pom.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 文件：

# 使用官方的 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

{"hosts": ["unix:///var/run/docker.sock", "tcp://0.0.0.0:2375"]
}

然后重启 Docker 服务：

bash

sudo systemctl restart docker

4. 编写 Jenkins Pipeline

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

groovy

pipeline {agent anystages {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. 测试流程

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

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

另外一个案例介绍

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

案例概述

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

步骤

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

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

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 凭证

导航到“Manage Jenkins” -> “Manage Credentials”。
添加全局凭证：
- 类型：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 项目

在 Jenkins 主页点击“New Item”。
输入项目名称，选择“Pipeline”，然后点击“OK”。

4.2 编写 Jenkins Pipeline 脚本

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

groovy

pipeline {agent anyenvironment {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}.tarssh 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}.tarssh 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

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

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. 测试整个流程

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