jenkins+springcloud+docker 自动化打包部署流程

已于 2022-05-17 10:34:27 修改
阅读量4.4k 收藏 13
点赞数 3
文章标签： jenkins 自动化 运维
于 2022-05-14 14:19:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39009944/article/details/124763508
版权

jenkin安装下载

在这里插入图片描述
大致流程说明：
1）开发人员每天把代码提交到Gitlab代码仓库
2）Jenkins从Gitlab中拉取项目源码，编译并打成jar包，然后构建成Docker镜像，将镜像上传到
Harbor私有仓库。
3）Jenkins发送SSH远程命令，让生产部署服务器到Harbor私有仓库拉取镜像到本地，然后创建容器。
4）最后，用户可以访问到容器

1、 从gitlab拉取代码（自己可以用gitee或者github，看自己公司用哪个），本次主要以流水线形式来演示如何自动化打包部署微服务的jar

在这里插入图片描述

2、整个流程以脚本式脚本来执行整个自动化流程（自己可以用脚本式语言） 这个语言可以不用写，里面可以生成代码片段的，我们copy就可以了

在这里插入图片描述
在这里插入图片描述
checkout([$class: ‘GitSCM’, branches: [[name: ‘*/master’]], extensions: [], userRemoteConfigs: [[credentialsId: ‘fa0ff0a7-3b63-46b5-aaed-a7b357c23abe’, url: ‘http://192.168.0.121:82/root/online2022_admin.git’]]])
在这里插入图片描述
把上面生成的语法copy到我们编辑的脚本式文件里面
在这里插入图片描述

3、验证脚本是否可以拉取gitlab代码

在这里插入图片描述
在这里插入图片描述
正常拉取代码了
在这里插入图片描述

4. Pipeline Script from SCM 刚才我们都是直接在Jenkins的UI界面编写Pipeline代码，这样不方便脚本维护，建议把Pipeline脚本放在项目中（一起进行版本控制）

1）在项目根目录建立Jenkinsfile文件，把内容复制到该文件中
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

5. 演示拉取不同分支的代码来编译

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

6. 演示可以选择一个或者多个微服务编译打包

安装Extended Choice Parameter插件,支持多选框
在这里插入图片描述
//编译并安装公共工程
sh “mvn -f common clean install”
在这里插入图片描述

添加可以多选的项目打包编译
在这里插入图片描述
在这里插入图片描述
checkboxes选中值得格式我们采用逗号分隔每个项目，每个项目里面项目名和端口号以@分隔
例如： 项目名称1@8001,项目名称2@8002

在这里插入图片描述
infrastructure/api_gateway@8222,service/service_acl@8009,service/service_cms@8004,service/service_edu@8001,service/service_msm@8005,service/service_order@8007,service/service_oss@8002,service/service_statistics@8008,service/service_ucenter@8160,service/service_vod@8003

网关,权限,轮播图管理,后台系统主模块,验证码模块,订单模块,阿里云存储文件模块,统计模块,前台系统模块,阿里云音视频模块

stage('编译构建') {

        //编译并安装公共工程
        echo '编译并安装公共工程'
        sh "mvn -f common clean install"

        for(int i=0;i<selectedProjects.size();i++){
            //取出每个项目的名称和端口
            def currentProject = selectedProjects[i];
            echo "${currentProject}"
            //项目名称
            def currentProjectName = currentProject.split('@')[0]
            //项目启动端口
            def currentProjectPort = currentProject.split('@')[1]
            echo "${currentProjectName}"
            echo "${currentProjectPort}"
            sh "mvn -f ${currentProjectName} clean package"
        }
}

上面得脚本中引用变量，必须在双引号里面，否则会有问题
在这里插入图片描述
注意该项目打包后jar大小是否是正常的，如果太小的话，证明jar里面是没有BOOT-INFO这个包的（自己可以用压缩工具打开看一下），这个jar是不能启动的。这种情况一般是spring-boot-maven-plugins不生效，
1）第一种情况：你的父项目没有继承spring-boot-parent，需要在每个微服务项目里面添加spring-boot-maven-plugin插件，并且指定每个微服务项目的入口文件（公共模块不需要引入spring-boot-maven-plugin插件）
在这里插入图片描述

在这里插入图片描述

<build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <!--因为我们得guli_parent项目没有以springboot作为复工程，所以需要指定子项目打可执行jar包程序入口-->
                    <mainClass>com.atguigu.gateway.ApiGatewayApplication</mainClass>
                </configuration>
                <!--最主要的是要添加 repackage goal，用来重新打jar或者war包。-->
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

2）第二种情况：你的父项目继承spring-boot-parent，那么只需要在父项目pom文件添加
spring-boot-maven-plugin插件，公共模块就排除spring-boot-maven-plugin插件就可以了

7. 编译打包后的jar，制作成docker 镜像

1）第一种办法（我们不采用）
在项目中生成Dockerfile 文件
在这里插入图片描述

进入该项目目录
docker build
–build-arg JAR_FILE=xx.jar
-f ${Dockerfile} -t ${projectImage} .

–build-arg是构建参数 JAR_FILE是我们Dockefile文件里面需要的参数
-f 指定Dockerfile位置（-f ${Dockerfile} 可以不写，默认会找该目录下的Dockerfile文件）
-t 后面的 projectImage表示镜像名称
最后.号是指镜像构建时打包上传到Docker引擎中的文件的目录，一定要加上去

2）第二种办法（采用），在项目中生成Dockerfile 文件，我们采用maven 有关dockerfile-maven-plugin插件，执行mvn dockerfile:build命令来生成镜像
Dockerfile文件内容：

# 拉取jdk8作为基础镜像
FROM openjdk:8-jdk-alpine
# 输入参数，改参数为打包后的jar包，例如 api_gateway/target/api_gateway-1.0-SNAPSHOT.jar
ARG JAR_FILE
# 添加jar到镜像并命名为app.jar, copy命令是把 api_gateway-1.0-SNAPSHOT.jar直接添加到镜像里面不解压，ADD是添加入镜像并且解压
COPY ${JAR_FILE} app.jar
# 镜像启动后暴露的端口
EXPOSE 8222
# jar运行命令，参数使用逗号隔开
ENTRYPOINT ["java","-jar","/app.jar"]

项目的pom文件添加dockerfile-maven-plugin插件
在这里插入图片描述

<build>
	<plugins>
		<plugin>
		    <groupId>com.spotify</groupId>
		    <artifactId>dockerfile-maven-plugin</artifactId>
		    <version>1.4.13</version>
		    <configuration>
		        <repository>${project.artifactId}</repository>
		        <buildArgs>
		            <JAR_FILE>target/${project.build.finalName}.jar</JAR_FILE>
		        </buildArgs>
		    </configuration>
		</plugin>
	</plugins>
</build>

在原有的Jenkinsfile文件添加

 sh "mvn -f ${currentProjectName} dockerfile:build"

在这里插入图片描述
jenkins构建结果
在这里插入图片描述
在这里插入图片描述
我们手动运行一下
docker run -di --name=api_gateway -p 8222:8222 api_gateway:latest
查看一下启动日志 （我这个项目是需要注册中心nacos，自己在nacos安装一下2.x版本nacos启动就可以了）
docker logs -f api_gateway
在这里插入图片描述
在这里插入图片描述
以上已经完成 选中的微服务项目编译打包，并且制作成docker镜像了，如果不需要私服镜像仓库的话，就部署和jenkins同一台机器上面的话，自己在Jenkinsfile文件加一下docker 运行镜像的shell命令就可以了，每次编译前都要停止对应项目的容器，删除容器和镜像。

如有需要搭建镜像私服Harbor来存储docker制作执行，并且新的服务器可以从Harbor上拉取镜像并且运行成容器的，请往下面看

7. jenkins把jar包构建成docker镜像，将镜像上传到我们得私有仓库里面（Harbor）

8. 安装docker-compose(1.25.1版本)

1）先安装docker-compose
[root@localhost bin]# sudo curl -L https://get.daocloud.io/docker/compose/releases/download/1.25.1/docker-compose-uname -s-uname -m -o /usr/local/bin/docker-compose

2）给docker-compose添加执行权限
[root@localhost bin]# sudo chmod +x /usr/local/bin/docker-compose

3）查看docker-compose是否安装成功
docker-compose -version

4）下载Harbor的压缩包（版本为：v1.9.2）
https://github.com/goharbor/harbor/releases

5）上传压缩包到linux，并解压
tar -xzf harbor-offline-installer-v1.9.2.tgz
mkdir /opt/harbor
mv harbor/* /opt/harbor
cd /opt/harbor

6）修改Harbor的配置
vi harbor.yml
修改hostname和port
hostname: 192.168.0.121
port: 85

7）安装Harbor
./prepare
./install.sh

8）启动Harbor
docker-compose up -d 启动
docker-compose stop 停止
docker-compose restart 重新启动

10）访问Harbor
http://192.168.0.121:85
默认账户密码：admin/Harbor12345
在这里插入图片描述

  1. 再harbor新建一个私有项目
    在这里插入图片描述
  2. 创建用户 (lijun/Lijun123456)
    在这里插入图片描述
    把该用户添加到该私有仓库中（可以给开发权限或者管理员权限）
    在这里插入图片描述

9. 给jenkins所在机器docker制作的镜像打标签和推送镜像到harbor的online2022_admin项目

先手动测试一波命令(测试)
1)给镜像打标签
docker tag api_gateway:latest 192.168.0.121:85/online2022_admin/api_gateway:v1

api_gateway:latest 是jenkins所在机器docker制作镜像名称和版本
192.168.0.121是harbors所在机器的ip
85是harbor应用程序的端口
online2022_admin 是在harbors上面创建的项目，待会镜像是传到该项目上

2)推送镜像到harbor私有仓库的online2022_admin项目里面
docker push 192.168.0.121:85/online2022_admin/api_gateway:v1
正常情况是推送失败的
以上的错误是jenkins上面机器的docker 不信任harbor造成的。

在 jenkins机器上，Docker把Harbor加入信任列表中
vi /etc/docker/daemon.json

{
 "registry-mirrors": ["https://zydiol88.mirror.aliyuncs.com"],
 "insecure-registries": ["192.168.0.121:85"]
}

docker push 192.168.0.121:85/online2022_admin/api_gateway:v1
#重启本地docker
systemctl restart docker

再次推送，会提示权限不足
在这里插入图片描述

在jenkins机器上docker登录harbor所在的机器
docker login -u 用户名 -p 密码 192.168.0.121:85
docker login -u lijun -p Lijun123456 192.168.0.121:85
在这里插入图片描述
docker push 192.168.0.121:85/online2022_admin/api_gateway:v1
推送成功了
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
把sh命令改造放进Jenkinsfile文件里面
//定义镜像名称(因为原本微服务项目前面还有一个父项目的，所以 必须获取到项目的真正名称 ，例如 infrastructure/api_gateway 变成 api_gateway）

//gitlab的凭证
def git_auth = "fa0ff0a7-3b63-46b5-aaed-a7b357c23abe"

//构建版本的名称
def tag = "latest"

//Harbor私服地址
def harbor_url = "192.168.0.121:85"

//Harbor的项目名称
def harbor_project_name = "online2022_admin"

// harbor用户名和密码
def username = "lijun"
def password = "Lijun123456"

def realProjectName = currentProjectName.split("/")
def realName = realProjectName[realProjectName.length-1]
def imageName = "${realName}:${tag}"

//登录
sh "docker login -u ${username} -p ${password} ${harbor_url}"

//给镜像打标签
sh "docker tag ${imageName} ${harbor_url}/${harbor_project_name}/${imageName}"

//上传镜像
sh "docker push ${harbor_url}/${harbor_project_name}/${imageName}"

//删除本地镜像 （根据镜像名称删除镜像和打标签的镜像，因为原本的镜像和打包后镜像是同一	个镜像id,无法通过镜像id删除镜像）
sh "docker rmi -f ${imageName}"
sh "docker rmi -f ${harbor_url}/${harbor_project_name}/${imageName}"

Jenkinsfile完整内容:

//gitlab的凭证
def git_auth = "fa0ff0a7-3b63-46b5-aaed-a7b357c23abe"

//构建版本的名称
def tag = "latest"

//Harbor私服地址
def harbor_url = "192.168.0.121:85"

//Harbor的项目名称
def harbor_project_name = "online2022_admin"

// harbor用户名和密码
def username = "lijun"
def password = "Lijun123456"


node {
    //把选择的项目信息转为数组
    def selectedProjects = "${project_name}".split(',')
    echo "${selectedProjects}"

    stage('拉取代码') {
        checkout([$class: 'GitSCM', branches: [[name: '*/${branch}']], extensions: [], userRemoteConfigs: [[credentialsId: "${git_auth}", url: 'http://192.168.0.121:82/root/online2022_admin.git']]])
    }

    stage('编译构建') {
        //编译并安装公共工程
        sh "mvn -f common clean install"

        for(int i=0;i<selectedProjects.size();i++){
            //取出每个项目的名称和端口
            def currentProject = selectedProjects[i];
            //项目名称
            def currentProjectName = currentProject.split('@')[0]
            //项目启动端口
            def currentProjectPort = currentProject.split('@')[1]

            // 编译打包选中微服务项目
            sh "mvn -f ${currentProjectName} clean package"

            // 生成镜像
            sh "mvn -f ${currentProjectName} dockerfile:build"

            //定义镜像名称(因为原本微服务项目前面还有一个父项目的，所以 必须获取到项目的真正名称 ，例如 infrastructure/api_gateway 变成 api_gateway）
            def realProjectName = currentProjectName.split("/")
            def realName = realProjectName[realProjectName.length-1]
            def imageName = "${realName}:${tag}"

            //登录
            sh "docker login -u ${username} -p ${password} ${harbor_url}"

            //给镜像打标签
            sh "docker tag ${imageName} ${harbor_url}/${harbor_project_name}/${imageName}"

            //上传镜像
            sh "docker push ${harbor_url}/${harbor_project_name}/${imageName}"

            //删除本地镜像 （根据镜像名称删除镜像和打标签的镜像，因为原本的镜像和打包后镜像是同一个镜像id,无法通过镜像id删除镜像）
            sh "docker rmi -f ${imageName}"
            sh "docker rmi -f ${harbor_url}/${harbor_project_name}/${imageName}"

        }
        // infrastructure/api_gateway@8222,service/service_acl@8009,service/service_cms@8004,service/service_edu@8001,service/service_msm@8005,service/service_order@8007,service/service_oss@8002,service/service_statistics@8008,service/service_ucenter@8160,service/service_vod@8003
        // 网关,权限,轮播图管理,后台系统主模块,验证码模块,订单模块,阿里云存储文件模块,统计模块,前台系统模块,阿里云音视频模块
    }
}

效果图在这里插入图片描述

在这里插入图片描述

如果怕harbor账号密码泄露，在jenkins凭证管理添加全局配置
在这里插入图片描述
添加后会自动生成id,这个id就可以直接关联harbor账号和密码了
在这里插入图片描述
用jenkins的流水线语法生成器生成脚本片段
在这里插入图片描述

withCredentials([usernamePassword(credentialsId: '262b0b77-61b6-493c-9bb4-bf0659365903', passwordVariable: 'password', usernameVariable: 'username')]) {
    // some block
}

改造后的Jenkinsfile内容

//gitlab的凭证
def git_auth = "fa0ff0a7-3b63-46b5-aaed-a7b357c23abe"

//构建版本的名称
def tag = "latest"

//Harbor私服地址
def harbor_url = "192.168.0.121:85"

//Harbor的项目名称
def harbor_project_name = "online2022_admin"

// harbor用户凭证（全局凭证管理那里配置）
def harbor_auth = "262b0b77-61b6-493c-9bb4-bf0659365903"


node {
    //把选择的项目信息转为数组
    def selectedProjects = "${project_name}".split(',')
    echo "${selectedProjects}"

    stage('拉取代码') {
        checkout([$class: 'GitSCM', branches: [[name: '*/${branch}']], extensions: [], userRemoteConfigs: [[credentialsId: "${git_auth}", url: 'http://192.168.0.121:82/root/online2022_admin.git']]])
    }

    stage('编译构建') {
        //编译并安装公共工程
        sh "mvn -f common clean install"

        for(int i=0;i<selectedProjects.size();i++){
            //取出每个项目的名称和端口
            def currentProject = selectedProjects[i];
            //项目名称
            def currentProjectName = currentProject.split('@')[0]
            //项目启动端口
            def currentProjectPort = currentProject.split('@')[1]

            // 编译打包选中微服务项目
            sh "mvn -f ${currentProjectName} clean package"

            // 生成镜像
            sh "mvn -f ${currentProjectName} dockerfile:build"

            //定义镜像名称(因为原本微服务项目前面还有一个父项目的，所以 必须获取到项目的真正名称 ，例如 infrastructure/api_gateway 变成 api_gateway）
            def realProjectName = currentProjectName.split("/")
            def realName = realProjectName[realProjectName.length-1]
            def imageName = "${realName}:${tag}"

            //给镜像打标签
            sh "docker tag ${imageName} ${harbor_url}/${harbor_project_name}/${imageName}"


            withCredentials([usernamePassword(credentialsId: '262b0b77-61b6-493c-9bb4-bf0659365903', passwordVariable: 'password', usernameVariable: 'username')]) {
                //登录
                sh "docker login -u ${username} -p ${password} ${harbor_url}"
                //上传镜像
                sh "docker push ${harbor_url}/${harbor_project_name}/${imageName}"
            }

            //删除本地镜像 （根据镜像名称删除镜像和打标签的镜像，因为原本的镜像和打包后镜像是同一个镜像id,无法通过镜像id删除镜像）
            sh "docker rmi -f ${imageName}"
            sh "docker rmi -f ${harbor_url}/${harbor_project_name}/${imageName}"

        }
        // infrastructure/api_gateway@8222,service/service_acl@8009,service/service_cms@8004,service/service_edu@8001,service/service_msm@8005,service/service_order@8007,service/service_oss@8002,service/service_statistics@8008,service/service_ucenter@8160,service/service_vod@8003
        // 网关,权限,轮播图管理,后台系统主模块,验证码模块,订单模块,阿里云存储文件模块,统计模块,前台系统模块,阿里云音视频模块
    }
}

10. 部署服务器（192.168.0.130）从harbor（192.168.121）上拉取镜像并且运行镜像

1）jenkins（192.168.0.120） 所在的机器 上生成密钥：
[root@mycentos .ssh]# ssh-keygen
不断回车就好了
在这里插入图片描述

2）拷贝公钥到远程服务器（192.168.0.130）

ssh-copy-id 192.168.0.130

在这里插入图片描述
3）尝试在jenkin（192.168.0.120）机器上ssh登录部署服务器（192.168.0.130）

如果连接失败jenkins尝试连接失败，请开启sshd服务
在这里插入图片描述

sudo service sshd start  //开启sshd服务

 ssh root@192.168.0.130

ssh root@192.168.0.130

4)jenkins 192.168.0.120（系统配置）->添加远程服务器

设置私钥位置
/root/.ssh/id_rsa
在这里插入图片描述
在这里插入图片描述
5）如果jenkins用ssh连接部署服务器失败的话，估计是jenkins不支持所在机器生成的私钥（机器版本太高了）

先移除known_hosts文件
rm -rf /root/.ssh/known_hosts

重新生成密钥
ssh-keygen -m PEM -t rsa -b 4096

重新把公钥给部署服务器
ssh root@192.168.0.130

  1. 生成调用部署服务器的脚本
    在这里插入图片描述
  2. 因为我们的调用的是我们自己的部署脚本，这个脚本是要传结果参数的，我改造一下生成的脚本
sshPublisher(publishers: [sshPublisherDesc(configName: 'pro_server', transfers: [sshTransfer(cleanRemote: false, excludes: '', execCommand: "/opt/jenkins_shell/deploy.sh ${harbor_url} ${harbor_project_name} ${realName} ${tag} ${currentProjectPort}", execTimeout: 120000, flatten: false, makeEmptyDirs: false, noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: '', remoteDirectorySDF: false, removePrefix: '', sourceFiles: '')], usePromotionTimestamp: false, useWorkspaceInPromotion: false, verbose: false)])

完整jenkins流水想脚本

//gitlab的凭证
def git_auth = "fa0ff0a7-3b63-46b5-aaed-a7b357c23abe"

//构建版本的名称
def tag = "latest"

//Harbor私服地址
def harbor_url = "192.168.0.121:85"

//Harbor的项目名称
def harbor_project_name = "online2022_admin"

// harbor用户凭证（全局凭证管理那里配置）
def harbor_auth = "262b0b77-61b6-493c-9bb4-bf0659365903"


node {
    //把选择的项目信息转为数组
    def selectedProjects = "${project_name}".split(',')
    echo "${selectedProjects}"

    stage('拉取代码') {
        checkout([$class: 'GitSCM', branches: [[name: '*/${branch}']], extensions: [], userRemoteConfigs: [[credentialsId: "${git_auth}", url: 'http://192.168.0.121:82/root/online2022_admin.git']]])
    }

    stage('编译构建') {
        //编译并安装公共工程
        sh "mvn -f common clean install"

        for(int i=0;i<selectedProjects.size();i++){
            //取出每个项目的名称和端口
            def currentProject = selectedProjects[i];
            //项目名称
            def currentProjectName = currentProject.split('@')[0]
            //项目启动端口
            def currentProjectPort = currentProject.split('@')[1]

            // 编译打包选中微服务项目
            sh "mvn -f ${currentProjectName} clean package"

            // 生成镜像
            sh "mvn -f ${currentProjectName} dockerfile:build"

            //定义镜像名称(因为原本微服务项目前面还有一个父项目的，所以 必须获取到项目的真正名称 ，例如 infrastructure/api_gateway 变成 api_gateway）
            def realProjectName = currentProjectName.split("/")
            def realName = realProjectName[realProjectName.length-1]
            def imageName = "${realName}:${tag}"

            //给镜像打标签
            sh "docker tag ${imageName} ${harbor_url}/${harbor_project_name}/${imageName}"


            withCredentials([usernamePassword(credentialsId: '262b0b77-61b6-493c-9bb4-bf0659365903', passwordVariable: 'password', usernameVariable: 'username')]) {
                //登录
                sh "docker login -u ${username} -p ${password} ${harbor_url}"
                //上传镜像
                sh "docker push ${harbor_url}/${harbor_project_name}/${imageName}"
            }

            //删除本地镜像 （根据镜像名称删除镜像和打标签的镜像，因为原本的镜像和打包后镜像是同一个镜像id,无法通过镜像id删除镜像）
            sh "docker rmi -f ${imageName}"
            sh "docker rmi -f ${harbor_url}/${harbor_project_name}/${imageName}"

            //=====以下为远程调用进行项目部署========
            sshPublisher(publishers: [sshPublisherDesc(configName: 'pro_server', transfers: [sshTransfer(cleanRemote: false, excludes: '', execCommand: "/opt/jenkins_shell/deploy.sh ${harbor_url} ${harbor_project_name} ${realName} ${tag} ${currentProjectPort}", execTimeout: 120000, flatten: false, makeEmptyDirs: false, noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: '', remoteDirectorySDF: false, removePrefix: '', sourceFiles: '')], usePromotionTimestamp: false, useWorkspaceInPromotion: false, verbose: false)])

        }



        // =================================这个是jenkins部署多参数用到的值，可以直接复制黏贴过去来改
        // infrastructure/api_gateway@8222,service/service_acl@8009,service/service_cms@8004,service/service_edu@8001,service/service_msm@8005,service/service_order@8007,service/service_oss@8002,service/service_statistics@8008,service/service_ucenter@8160,service/service_vod@8003
        // 网关,权限,轮播图管理,后台系统主模块,验证码模块,订单模块,阿里云存储文件模块,统计模块,前台系统模块,阿里云音视频模块
    }
}

8)部署服务器（192.168.0.130） 添加harbot信任列表

{
 "registry-mirrors": ["https://zydiol88.mirror.aliyuncs.com"],
 "insecure-registries": ["192.168.0.121:85"]
}

在这里插入图片描述

  1. 部署服务器（192.168.0.130）重启docker
    systemctl restart docker
    如果在192.168.0.130的docker 登录 192.168.0.121（harbor）失败的话，重启一下192.168.0.121的harbor
cd  /opt/harbor   
docker-compose stop
docker-compose up -d

10)部署服务器（192.168.0.130）的deploy.sh内容

#! /bin/sh
#接收外部参数
harbor_url=$1
harbor_project_name=$2
project_name=$3
tag=$4
port=$5
imageName=$harbor_url/$harbor_project_name/$project_name:$tag
echo "$imageName"
#查询容器是否存在，存在则删除
# docker ps -a 查询所有的容器（无论启动还是停止）
# grep -w 根据一个单词来全匹配查询
# awk '{print $1}' 对于获取来的每行数据，按空格分隔，取第1列的值，$2表示拿第二列的值
containerId=`docker ps -a | grep -w ${project_name}:${tag} | awk '{print $1}'`
if [ "$containerId" != "" ] ; then
    #停掉容器
    docker stop $containerId
    #删除容器
    docker rm $containerId
    echo "成功删除容器"
fi
#查询镜像是否存在，存在则删除
imageId=`docker images | grep -w $project_name | awk '{print $3}'`
if [ "$imageId" != "" ] ; then
    #删除镜像
    docker rmi -f $imageId
    echo "成功删除镜像"
fi
# 登录Harbor私服（自己手动登录harbor的话记得加上harbor的端口号，例如docker login -u lijun -p Lijun123456 192.168.0.121:85）
docker login -u lijun -p Lijun123456 $harbor_url
# 下载镜像
docker pull $imageName
# 启动容器
docker run -di -p $port:$port $imageName
echo "容器启动成功"

9）效果图
在这里插入图片描述
在这里插入图片描述

qq_39009944
关注
  • 3
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
Jenkins+Docker+Gitee+SpringBoot自动化部署
LinXin
06-22 936
Centos7 下 Jenkins+DOcker+Gitee+SpringBoot安装和部署
Jenkins K8S Docker 一键部署SpringCloud微服务
qq_22917569的博客
05-02 2314
一键部署springcloud微服务，需要用到 Jenkins K8S Docker等工具，本文使用jenkins部署，流程如下图开发者将代码push到git运维人员通过jenkins部署，自动到git上pull代码通过maven构建代码将maven构建后的jar打包成docker镜像 并 push docker镜像到docker registry通过k8s发起发布/更新 服务操作其中 2~5步骤都会在jenkins中进行操作。
docker中安装jenkins，并在node和cloud上跑通基于源码控制SCM的pipeline
最新发布
qq_29022265的博客
05-19 1360
从安装jenkins到创建jenkins的node和cloud，最后再将scm和FreeStyle两种流水线跑通。
spring boot微服务项目打包、部署（docker）
abc123adc的博客
08-30 1965
资源文件不需要打包，在其他模块打包的时候，使用该插件会自动将对应依赖的jar打包到依赖它的可执行jar包中，阔以使用压缩工具打开jar包检测所有依赖是否都已经成功打包。编写Dockerfile 用于构建docker镜像，gateway-0.0.1-SNAPSHOT.jar为原jar包名，/app/gateway.jar、CMD ["gateway.jar"]为复制到容器后jar包名，请自行修改。因为父项目管理了子项目，只需要在父项目先clean，再package进行打包，控制台会打印打包详细信息。
Java教程自动化部署Jenkins从环境配置到项目开发
12-13
1、持续集成及Jenkins介绍 2、Jenkins安装和持续集成环境配置 3、Jenkins构建Maven项目 4、Jenkins+Docker+SpringCloud微服务持续集成 5、基于Kubernetes/K8S构建Jenkins微服务持续集成平台
springboot shell启动脚本
Forevermark的博客
07-31 1410
#!/bin/bash APP_NAME=ikoa-191217.jar #使用说明，用来提示输入参数 usage() { echo "Usage: sh 执行脚本.sh [start|stop|restart|status]" exit 1 } #检查程序是否在运行 is_exist(){ pid=`ps -ef|grep $APP_NAME|grep -v grep|awk '{print $2}' ` #如果不存在返回1，存在返回0 if [ -z "${pi
Jenkins+Docker 实现一键自动化部署项目.docx
11-06
Jenkins+Docker 实现一键自动化部署项目 本文将详细介绍如何使用 Jenkins 与 Docker 实现一键自动化部署项目。该项目环境基于 Centos 7，使用 Git（Gitee）版本控制系统。整个过程可以分为四个步骤：安装 Docker、...
基于Spring Boot+Spring Cloud+Docker的个人理财系统源码.zip
08-30
此外，可能还使用了持续集成/持续部署(CI/CD)工具如Jenkins，实现自动化测试和部署。 综上所述，这个个人理财系统是一个涵盖了多种现代技术和最佳实践的综合性项目，对于学习和掌握Java企业级应用开发有很高的参考...
spring boot+spring Cloud+Eureka纯净版
11-03
9. **Docker与Kubernetes**：可能还会涉及容器化部署，Docker用于打包应用，Kubernetes则用于集群管理和自动化部署。 10. **持续集成/持续部署(CI/CD)**：如Jenkins或GitLab CI/CD，实现自动化测试、构建和发布流程...
Spring Boot+spring Cloud纯净版
11-03
4. **持续集成/持续部署（CI/CD）**: 使用Jenkins、GitLab CI/CD等工具实现自动化构建和部署。 5. **测试策略**: 实施单元测试、集成测试和端到端测试，确保微服务的质量和稳定性。 6. **容器化和编排**: Docker...
Jenkins 自动打包发布 SpringCloud 微服务项目(含脚本)
jaylee的博客
08-01 2143
CI 的整体逻辑 : 拉取代码 >>> 设置编译命令(方法) >>> 编译 >>> 生成结果(二进制文件或包)
jenkins部署springboot项目,打包为docker镜像
胖虎儿的博客
10-16 1810
jenkins持续集成springboot打包镜像推送到远端仓库
【学习Docker（七）】详细讲解Jenkins部署SpringCloud微服务项目，Docker-compose启动
你若为我繁华，我愿成你烟花
03-03 1052
座右铭：《坚持有效输出，创造价值无限》本文介绍使用Jenkins部署SpringCloud微服务项目
一键部署 SpringCloud 微服务，yyds！
码猿技术专栏
01-24 45
大家好，我是不才陈某~一键部署springcloud微服务，需要用到 Jenkins K8S Docker等工具，自行安装即可。本文使用jenkins部署，流程如下图开发者将代码push到git运维人员通过jenkins部署，自动到git上pull代码通过maven构建代码将maven构建后的jar打包成docker镜像 并 push docker镜像到docker registry通过k8s发起...
Jenkins 微服务持续集成十四（Spring Cloud 微服务四）
LlZzSss的博客
03-20 499
目录一、Jenkins+Docker+SpringCloud 持续集成流程说明二、利用 Jenkins 打包微服务项目1. 生成公共子工程 pom 文件1.1 修改 Jenkinsfile1.2 修改各个 pom.xml2. 开始编译打包所有微服务项目2.1 修改 Jenkinsfile 并提交2.2 打包微服务项目三、利用 dockerfile-maven-plugin 插件构建 Docker 镜像1. 在每个微服务项目的 pom.xml 加入 dockerfile-maven-plugin 插件2. 在每个
使用Docker+Jenkins+Gitee自动化部署SpringBoot项目
wy971744839的博客
09-15 595
使用Docker+Jenkins+Gitee自动化部署SpringBoot项目
gitlab cicd自动打包发布到私有仓库
ice_bird的专栏
03-29 3440
首先安装gitlab runner 查看安装说明 sudo curl -L --output /usr/local/bin/gitlab-runner https://gitlab-runner-downloads.s3.amazonaws.com/latest/binaries/gitlab-runner-linux-amd64 # Give it permission to execute sudo chmod +x /usr/local/bin/gitlab-runner # Cr.
Jenkins持续集成替换为gitlab.yml镜像打包(微服务or消费端)
weixin_46484674的博客
01-18 6022
如何让gitlab管道停止并要求我输入变量进行个性化打包？背景Gitlab CI yaml.gitlab-ci.yml文件内容编写1. after_script2. stages 背景 gitlab 管道停止并要求我输入变量？ 使用Jenkins打包阿里云镜像包，由于Jenkins环境不稳定，越是着急Jenkins打包镜像越是慢； 故而换成Gitlab CI yaml进行阿里云镜像打包。（两种都是运行dockerfile） Gitlab CI yaml GitLab CI使用YAML文件(.gitlab-c
jenkins +gitlab+maven 持久化集成部署
weixin_42269089的博客
02-27 807
jenknis +gitlab +springboot 持久化集成发布
jenkins+docker+k8s 自动化部署springcloud项目 简书
08-31
Jenkins是一款开源的持续集成工具，它可以帮助开发团队自动化地构建、测试和部署软件项目。在Jenkins中配置Docker插件后，我们可以结合Docker技术来进行自动化部署。Docker是一种轻量级的容器化技术，它可以将应用程序和其依赖的环境打包成一个可移植的容器，方便在不同的环境中部署和运行。 而Kubernetes（简称K8s）是一个开源的容器编排平台，它可以管理和调度Docker容器集群。通过在K8s中创建Pod、Service等资源对象，我们可以实现Spring Cloud项目的自动化部署。 首先，我们可以使用Jenkins的Pipeline功能来编写自动化部署的流水线脚本。流水线脚本可以定义一系列的步骤，包括构建、测试和部署等。在流水线脚本中，我们可以使用Docker插件来创建Docker镜像，并将其推送到Docker仓库。接着，我们可以使用K8s插件来在Kubernetes集群中创建相关的资源对象，如Deployment和Service等。 在自动化部署过程中，我们可以将Spring Cloud项目的源代码与Dockerfile放在一个Git仓库中，并通过Jenkins的Webhook功能来触发自动化部署流水线。当有新的代码提交时，Jenkins会自动拉取最新的代码，并执行流水线脚本。在流水线脚本中，我们可以使用Maven或Gradle等工具来构建和打包Spring Cloud项目。然后，通过Docker插件创建可运行的Docker镜像，并将其推送到Docker仓库。 最后，使用K8s插件在Kubernetes集群中创建相关的资源对象，如Deployment和Service等。通过创建Deployment对象，我们可以定义应用程序的副本数和容器的镜像。通过创建Service对象，我们可以定义应用程序可以访问的网络端口和负载均衡规则。 通过Jenkins、Docker和Kubernetes的自动化部署，我们可以实现Spring Cloud项目的快速、可靠和可重复部署。这种自动化部署的方式可以提高开发效率和部署质量，同时也降低了运维成本和风险。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值