SpringBoot 项目部署笔记

部署一般思路是先拉取代码仓库内的最新代码构建打包好，（也许是构建成 docker 镜像）然后上传至目标服务器,服务器来运行即可。

1. 直接通过 jar 包部署

本地直接 build package 成 jar 包，上传至服务器

ps -ef|grep XXX  #查找项目进程

sudo kill -9 19727 #杀掉项目进程

nohup sudo  java -jar *.jar >> app.log & #后台运行 jar  

&代表让该命令在后台执行

2. 通过 Jenkins + Git 部署

jenkins 一般与项目运行的服务器分开，jenkins 服务器完成 Git 拉取代码 构建 打包等工作，然后jenkins 可以通过 SSH 将打包好的文件上传到目标服务器，然后在目标服务器执行命令进行运行。

配置 Jenkins

在一台服务器上安装 Jenkins，作为 tool 服务器
可以直接安装，也可以 docker 安装。
拉取镜像

run 启动

docker \
run \
-d \
-p 8880:8080 \   # 映射端口
-p 10241:50000 \ # 映射端口
# 物理卷映射，就是本地与容器共享磁盘，格式(本地目录:容器目录）
-v /home/zry/mount/jenkins_home:/var/jenkins_home  \
-v  /root/maven-3.8.7/apache-maven-3.8.7:/usr/local/maven \
-v /etc/localtime:/etc/localtime \ 
--name jenkins \ # 容器名
jenkins/jenkins:jdk11

查看密码

	docker logs jenkins

或者

 cat /root/jenkins/secrets/initialAdminPassword

jenkins 配置 jdk 地址

java -version
which java
ls -lrt /usr/bin/java

echo $JAVA_HOME

jenkins 配置 maven 地

jenkins 配置 git 密钥,仓库地址

jenkins 一般与项目运行的服务器分开，jenkins 服务器完成拉取代码 构建 打包等工作，然后jenkins 可以通过 SSH 将打包好的文件上传到目标服务器，然后在目标服务器执行命令进行运行。
连接到项目部署的服务器 部分配置：

最后构建项目时也可以使用运行编写好的 shell 脚本 ，编写shell脚本（主要是构建项目、拷贝文件到指定目录、重启项目）
网上找了个 shell 脚本例子,灵活参照

#!/bin/bash
# #!/bin/bash是指此脚本使用/bin/bash来解释执行。其中，#!是一个特殊的表示符，其后，跟着解释此脚本的shell路径。bash只是shell的一种，还有很多其它shell，如：sh,csh,ksh,tcsh,...
# #!/bin/bash只能放在第一行，如果后面还有#!，那么只能看成是注释。

#服务名称

SERVER_NAME=SpringBoot_AutotTest

#源jar路径，mm打包完成之后，target目录下的jar包名称，也可选择成为war包，war包 可移动到Tomcat的。
JAR_NAME=jekins-0.0.1-SNAPSHOT


#target打包生成jar包的目录

JAR_PATH=/var/jenkins_home/workspace/SpringBoot_AutotTest/target    # 以具体的打包位置为准，可以先构建一次项目，通过日志查看打包的目录

#打包完成之后，把iar包移动到运行jar包的目录
JAR_WORK_PATH=/var/jenkins_home/workspace/SpringBoot_AutotTest/target

echo "查询进程id-->$SERVER_NAME"
PID=`ps -ef | grep "$SERVER_NAME" | awk '{print $2}'`
echo"得到进程ID: $PID"
echo"结束进程"
for id in $PID
do
kill -9 $id
echo "killed $id" 
done
echo"结束进程完成"

#复制jar包到执行目录_

echo" 复制jar包到执行目录:cp $JAR_PATH/$JAR_NAME.jar $JAR_WORK_PATH"
cp $JAR_PATH/$JAR_NAME.jar $JAR_WORK_PATH
echo"复 制jar包完成"
cd $JAR_WORK_PATH
#修改文件权限
chmod 755 $JAR_NAME.jar

#前台启动
#java -jar $JAR_NAME.jar

#后台启动
BUILD_ID=dontKillMe nohup java -jar $JAR_NAME.jar &

3. 基于 Docker + Jenkins + Git 实现自动化部署

其它

SpringBoot 构建 Docker 镜像的最佳 3 种方式

一、Spring Boot maven 插件 的 build-image

Spring Boot 预装了自己的用于构建 Docker 镜像的插件，我们无需进行任何更改，因为它就在 pom.xml 中的 spring-boot-starter-parent。

你不需要写 Dockerfile，也不用操别的心，plugin 都帮你做了，例如 Spring 建议的安全、内存、性能等问题。

pom.xml 例子

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
                <configuration>
                    <image>
                        
                        <name>lovezry666/${project.artifactId}:${project.version}name>
                        <publish>truepublish>
                        
                        <pullPolicy>IF_NOT_PRESENTpullPolicy>
                    image>
                    <docker>
                        <builderRegistry>
                            <username>lovezry666username>
                            <password>asdw147258369password>
                            <url>https://hub.docker.comurl>
                            <email>[email protected]email>
                        builderRegistry>
                    docker>
                configuration>
            plugin>
        plugins>
    build>

二、jib-maven-plugin

Jib 是一个 Maven 和 Gradle 插件，用来创建 Docker 镜像。

这个插件有一个非常明显的特点：不需要本地安装 Docker，这对持续集成是非常方便的，Jib 可以直接推送到指定的 Docker 仓库。

Jib 同样也不需要写 Dockerfile。

使用起来也非常方便，不需要改代码，也可以不改动 pom.xml。

只需要执行：

mvn compile com.google.cloud.tools:jib-maven-plugin:2.3.0:dockerBuild

三、dockerfile-maven-plugin

这个插件就需要我们写 Dockerfile 了

Dockerfile 需要放在项目的根目录下，和 pom.xml 在一起。

DockerFile 示例

FROM bitnami/java:1.8
EXPOSE 80
# 维护者信息
MAINTAINER zry
ARG JAR_FILE
ADD target/${JAR_FILE} app.jar
ENTRYPOINT ["java", "-jar","app.jar"]

dockerfile-maven-plugin pom.xml 例子

          <plugin>
                <groupId>com.spotifygroupId>
                <artifactId>dockerfile-maven-pluginartifactId>
                <version>1.4.13version>
                <executions>
                    <execution>
                        <id>defaultid>
                        <goals>
                            <goal>buildgoal>
                            <goal>pushgoal>
                        goals>
                    execution>
                executions>
                <configuration>
                    <contextDirectory>${project.basedir}contextDirectory>
                    
                    <dockerfile>${project.basedir}dockerfile>
                    
                    <repository>${docker.repository.registry}/${docker.repository.namespace}/${project.artifactId}repository>
                    <tag>${project.version}tag>
                    
                    

                    <username>lovezry666username>
                    <password>asdw147258369password>
                    <buildArgs>
                        <JAR_FILE>${project.build.finalName}.jarJAR_FILE>
                    buildArgs>
                configuration>
            plugin>

使用spring-boot-maven-plugin插件，一键构建镜像

spring boot 2.4.0 的spring-boot-maven-plugin插件提供了一键构建镜像的功能，不需要自己写Dockerfile文件即可构建镜像，关于插件是如何实现自动构建镜像的，可以查看下面的官方文档，这里只是简单介绍如何使用此插件实现一键构建镜像。
官方文档：https://docs.spring.io/spring-boot/docs/2.4.0/maven-plugin/reference/htmlsingle/#build-image

docker compose 简化docker中多个镜像启动

它可以用来快速搭建你需要的环境。
查看docker-compose版本

docker-compose -version

编写docker-compose.yml文件

Docker Compose将所管理的容器分为三层，工程、服务及容器。docker-compose.yml中定义所有服务组成了一个工程，services节点下即为服务，服务之下为容器。容器与容器直之间可以以服务名称为域名进行访问，比如在mall-tiny-docker-compose服务中可以通过jdbc:mysql://db:3306这个地址来访问db这个mysql服务。

docker-compose up -d

看几个 docker-compose.yaml 文件几个例子：
1.

version: "3.5"

services:
  zry-mysql:
    image: mysql:8.0
    container_name: zry-mysql
    restart: always
    environment:
      - MYSQL_ROOT_PASSWORD=root
    ports:
      - 3306:3306
    volumes:
      - ./mysql/data:/var/lib/mysql
      - ./mysql/conf.d:/etc/mysql/conf.d
      - ./mysql/initdb:/docker-entrypoint-initdb.d
  redis:
    image: redis:6.2
    container_name: redis
    restart: always
    ports:
      - 6379:6379
    volumes:
	  - /home/zry/docker/redis/conf/redis.conf:/etc/redis/redis.conf 
	  - /home/zry/docker/redis/data:/data
    # 指定服务名称
  mall-tiny-docker-compose:
    # 指定服务使用的镜像
    image: mall-tiny-docker-compose:0.0.1-SNAPSHOT
    # 指定容器名称
    container_name: mall-tiny-docker-compose
    # 指定服务运行的端口
    ports:
      - 8080:8080
    # 指定容器中需要挂载的文件
    volumes:
      - /etc/localtime:/etc/localtime
      - /mydata/app/logs:/var/logs

version: "3.7"
# zookeeper: 172.26.0.10
# kafka: 172.26.0.11
# flink: - job manager 172.26.0.20
#        - task manager(s) random assigment in 172.26.0.0/24
services:
  ZooKeeper:
    image: ubuntu/zookeeper
    container_name: ZooKeeper
    hostname: ZooKeeper
    volumes:
      - ./data:/data
    ports:
      - "2181:2181"
    networks:
      kafka-flink-cluster-network:
        ipv4_address: 172.26.0.10

  Kafka:
    image: wurstmeister/kafka
    ports:
      - "9092:9092"
    depends_on:
      - ZooKeeper
    environment:
      KAFKA_ADVERTISED_HOST_NAME: 127.0.0.1
      KAFKA_MESSAGE_MAX_BYTES: 52428800  # 50M
      KAFKA_CREATE_TOPICS: "topic_one:1:1,topic_two:3:1"
      KAFKA_ZOOKEEPER_CONNECT: ZooKeeper:2181
    volumes:
      - ./kafka-logs:/kafka
    networks:
      kafka-flink-cluster-network:
        ipv4_address: 172.26.0.11

  FlinkJobManager:
    image: flink:1.14.4-scala_2.12-java8
    container_name: FlinkJobManager
    hostname: FlinkJobManager
    volumes:
      - ./flink-jobmanager:/data
    expose:
      - "6123"
    links:
      -  Kafka
    networks:
      kafka-flink-cluster-network:
        ipv4_address: 172.26.0.20
    ports:
      - "8081:8081"
    command: jobmanager
    environment:
      - |
        FLINK_PROPERTIES=
        jobmanager.rpc.address: FlinkJobManager
 
  FlinkTaskManager:
    image: flink:1.14.4-scala_2.12-java8
    #container_name: FlinkTaskManager
    #hostname: FlinkTaskManager
    expose:
      - "6121"
      - "6122"
    depends_on:
      - FlinkJobManager
    command: taskmanager
    scale: 2
    links:
      - "FlinkJobManager:jobmanager"
    environment:
      - |
        FLINK_PROPERTIES=
        jobmanager.rpc.address: FlinkJobManager
        taskmanager.numberOfTaskSlots: 2
    networks:
      - kafka-flink-cluster-network


networks:
  kafka-flink-cluster-network:
    # external: true
    driver: bridge
    ipam:
      config:
        - subnet: 172.26.0.0/24