SpringCloud微服务以及集成Gogs+Jenkins

第一步：环境准备

系统环境：Centos7.6

①部署规划

编号 主机名称 IP地址 角色
1 sh1 192.168.31.151 SpringCloud01服务器
2 sh2 192.168.31.152 SpringCloud02服务器

②软件列表

软件名称 安装方式 进度
JDK17 SHELL脚本 √
MVN SHELL脚本 √
DOCKER SHELL脚本 √
GOGS SHELL脚本 √
DOCKER-COMPOSE SHELL脚本 √

0.微服务环境准备

①克隆母鸡或模板机，生产sh1服务器和sh2服务器

②更改主机名称，采用FQDN格式【这里不采用】

1
2
3
4
5
6
7
#192.168.31.151 
hostnamectl set-hostname sh1
su

#192.168.31.152
hostnamectl set-hostname sh2
su

③更改服务器的IP地址（使用静态模式）

1
2
3
4
5
6
7
# vim /etc/sysconfig/network-scripts/ifcfg-ens33
...
IPADDR="192.168.31.151"
NETMASK="255.255.255.0"
GATEWAY="192.168.31.2"
DNS1="114.114.114.114"
...

1.JDK17环境安装

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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
#!/bin/bash
# -------------------------------------------------
# Script Name: java.sh
# Author: Flaw
# -------------------------------------------------
# 欢迎语
echo -e "\033[36m
███╗   ██╗ ██████╗     ██╗  ██╗ ██████╗ ███╗   ███╗███████╗    ██╗     ██╗██╗  ██╗███████╗    
████╗  ██║██╔═══██╗    ██║  ██║██╔═══██╗████╗ ████║██╔════╝    ██║     ██║██║ ██╔╝██╔════╝    
██╔██╗ ██║██║   ██║    ███████║██║   ██║██╔████╔██║█████╗      ██║     ██║█████╔╝ █████╗      
██║╚██╗██║██║   ██║    ██╔══██║██║   ██║██║╚██╔╝██║██╔══╝      ██║     ██║██╔═██╗ ██╔══╝      
██║ ╚████║╚██████╔╝    ██║  ██║╚██████╔╝██║ ╚═╝ ██║███████╗    ███████╗██║██║  ██╗███████╗    
╚═╝  ╚═══╝ ╚═════╝     ╚═╝  ╚═╝ ╚═════╝ ╚═╝     ╚═╝╚══════╝    ╚══════╝╚═╝╚═╝  ╚═╝╚══════╝    
                                                                                              
 ██╗██████╗ ███████╗    ██████╗     ██████╗     ██╗                                           
███║╚════██╗╚════██║   ██╔═████╗   ██╔═████╗   ███║                                           
╚██║ █████╔╝    ██╔╝   ██║██╔██║   ██║██╔██║   ╚██║                                           
 ██║██╔═══╝    ██╔╝    ████╔╝██║   ████╔╝██║    ██║                                           
 ██║███████╗   ██║  ██╗╚██████╔╝██╗╚██████╔╝██╗ ██║                                           
 ╚═╝╚══════╝   ╚═╝  ╚═╝ ╚═════╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝

BY: \033[32mFlaw\033[0m
"

# 检查用户是否为root
if [ "$(id -u)" != "0" ]; then
        echo -e "\033[31m脚本运行中需要root权限,请提权后重试\033[0m" 1>&2
        exit 1
fi

clear

# 检查是否已安装必要的命令
required_commands=("wget" "rpm" "tar" "ln" "sed" "iptables" "systemctl")
for cmd in "${required_commands[@]}"; do
    if ! command -v "$cmd" >/dev/null 2>&1; then
        echo -e "\033[33m检测到缺少 $cmd 命令,正在安装...\033[0m"
        yum install -y "$cmd"
    fi
done

# 检查本地是否已安装 Java 环境
installed_java=$(rpm -qa | grep -E '^java-|^jdk-')
if [ -n "$installed_java" ]; then
    echo -e "\033[33m检测到本地已安装 Java 环境,正在卸载...\033[0m"
    rpm -e --nodeps $installed_java
    echo -e "\033[32m卸载完成\033[0m"
else
    echo -e "\033[32m本地未安装 Java 环境\033[0m"
fi

# 下载 JDK 安装包
jdk_file="/opt/jdk-17.0.10_linux-x64_bin.tar.gz"
if [ ! -f "$jdk_file" ]; then
    echo -e "\033[33m正在下载 JDK 安装包...\033[0m"
    wget  https://dlink.host/1drv/aHR0cHM6Ly8xZHJ2Lm1zL3UvcyFBaVlDNncwZHotYlJmT0dMZ3ZVLUY0WGlINDA_ZT1PbEc3VEI.tar.gz -O $jdk_file
    echo -e "\033[32m下载完成\033[0m"
else
    echo -e "\033[32m检测到 JDK 安装包已存在\033[0m"
fi

echo -e "\033[33m正在安装 JDK...\033[0m"
tar -zxf $jdk_file -C /usr/local/ >/dev/null 2>&1
ln -sf /usr/local/jdk-17.0.10 /usr/local/jdk

echo -e "\033[33m正在配置环境变量...\033[0m"
touch /opt/temp.txt
echo 'JAVA_HOME=/usr/local/jdk' >>/opt/temp.txt
echo 'PATH=$JAVA_HOME/bin:$PATH' >>/opt/temp.txt
echo 'CLASSPATH=$JAVA_HOME/jre/lib/ext:$JAVA_HOME/lib/tools.jar' >>/opt/temp.txt
echo 'export PATH JAVA_HOME CLASSPATH' >>/opt/temp.txt
sed -i -e '$r /opt/temp.txt' /etc/profile
rm -f /opt/temp.txt
source /etc/profile

echo -e "\033[32m JDK 安装完成\033[0m"

setenforce 0 >/dev/null 2>&1
iptables -F >/dev/null 2>&1
systemctl stop firewalld >/dev/null 2>&1
systemctl disable firewalld >/dev/null 2>&1
systemctl stop NetworkManager >/dev/null 2>&1
systemctl disable NetworkManager >/dev/null 2>&1

echo -e "\033[32m防火墙和网络管理器已关闭\033[0m"

2.MVN安装

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
#!/bin/bash


# 定义变量
MAVEN_VERSION=3.8.6
MAVEN_HOME=/opt/maven
MAVEN_DOWNLOAD_LINK="/opt/apache-maven-3.8.6-bin.tar.gz"

# 彩色输出函数
echo_red() { echo -e "\033[31m$1\033[0m"; }
echo_green() { echo -e "\033[32m$1\033[0m"; }
echo_blue() { echo -e "\033[34m$1\033[0m"; }

yum install wget -y

echo_blue "第一步：上传并解压 Maven 到 /opt..."
cd /opt
wget -O apache-maven-3.8.6-bin.tar.gz https://dlink.host/1drv/aHR0cHM6Ly8xZHJ2Lm1zL3UvcyFBaVlDNncwZHotYlJlN1ZQb05adU1VV0FhWlU_ZT1SMFh2QnU.tar.gz

# 第一步：上传并解压 Maven 到 /opt
echo_blue "第一步：上传并解压 Maven 到 /opt..."
sudo cp $MAVEN_DOWNLOAD_LINK /opt
cd /opt
sudo tar -zxvf $(basename $MAVEN_DOWNLOAD_LINK)

# 第二步：移动解压文件夹到 maven
echo_blue "第二步：移动解压文件夹到 maven..."
sudo mv apache-maven-$MAVEN_VERSION maven

# 第三步：设置环境变量
echo_blue "第三步：设置环境变量..."
echo "MAVEN_HOME=${MAVEN_HOME}" | sudo tee -a /etc/profile
echo 'export PATH=${MAVEN_HOME}/bin:${PATH}' | sudo tee -a /etc/profile
source /etc/profile

# 第四步：验证安装结果
echo_blue "第四步：验证安装结果..."
mvn -version

# 显示完成信息
echo_green "Maven 安装脚本完成。"

3.Docker安装

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
#!/bin/bash

# 检查并清理现有的Docker环境
echo -e "\033[34m检查并清理现有的Docker环境...\033[0m"
if command -v docker &>/dev/null; then
    echo -e "\033[33m发现现有Docker环境，准备清理...\033[0m"
    sudo systemctl stop docker
    sudo yum remove docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-ce-rootless-extras
    sudo rm -rf /var/lib/docker
    sudo rm -rf /var/lib/containerd
    echo -e "\033[32m现有Docker环境已清理完成。\033[0m"
else
    echo -e "\033[32m没有发现现有Docker环境。\033[0m"
fi

# 2.1 安装Docker

# （1）更新yum包到最新
echo -e "\033[34m更新yum包到最新...\033[0m"
sudo yum update -y

# （2）安装必要的软件包
echo -e "\033[34m安装必要的软件包...\033[0m"
sudo yum install -y yum-utils device-mapper-persistent-data lvm2

# （3）设置yum源为阿里云
echo -e "\033[34m设置yum源为阿里云...\033[0m"
sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

# （4）安装docker
echo -e "\033[34m安装docker...\033[0m"
sudo yum install docker-ce -y

# （5）安装后查看docker版本
echo -e "\033[34m查看docker版本...\033[0m"
docker -v

# 2.2 设置ustc的镜像
echo -e "\033[34m配置ustc镜像加速器...\033[0m"
# 创建或编辑daemon.json文件
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://docker.mirrors.ustc.edu.cn"]
}
EOF

# 2.3 Docker的启动与停止

# 启动docker
echo -e "\033[34m启动docker服务...\033[0m"
sudo systemctl start docker

# 可选：设置Docker开机自启
echo -e "\033[34m设置Docker开机自启...\033[0m"
sudo systemctl enable docker

echo -e "\033[32mDocker安装与配置完成！\033[0m"

echo -e "\033[34m当前Docker安装版本\033[0m"
docker -v

4.安装docker-compose

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
#!/bin/bash
echo -e "\033[33m正在安装wget...\033[0m"
yum install wget -y
# 检查是否已安装docker-compose
if command -v docker-compose &> /dev/null
then
    echo -e "\e[1;32mDocker Compose 已经安装，版本信息如下：\e[0m"
    docker-compose -v
    exit 0
else
    echo -e "\e[1;31m未检测到Docker Compose，开始安装...\e[0m"
fi

# 下载docker-compose
echo -e "\e[1;34m正在下载 Docker Compose...\e[0m"
wget -O /opt/docker-compose-linux-x86_64 https://dlink.host/1drv/aHR0cHM6Ly8xZHJ2Lm1zL3UvcyFBaVlDNncwZHotYlJmeFVpakRsVjlYUXlsOUU_ZT1Hdk1qM00..file

# 修改权限
echo -e "\e[1;34m修改权限...\e[0m"
chmod +x /opt/docker-compose-linux-x86_64

# 移动到/usr/bin
echo -e "\e[1;34m移动文件到 /usr/bin 目录...\e[0m"
mv /opt/docker-compose-linux-x86_64 /usr/bin/docker-compose

# 验证安装结果
if command -v docker-compose &> /dev/null
then
    echo -e "\e[1;32mDocker Compose 安装成功，版本信息如下：\e[0m"
    docker-compose -v
else
    echo -e "\e[1;31mDocker Compose 安装失败，请检查脚本和网络连接。\e[0m"
    exit 1
fi

5.搭建私有化仓库并上传JAVA8

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
#!/bin/bash

# 获取本机IP地址
LOCAL_IP=$(hostname -I | awk '{print $1}')

# 定义颜色变量
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[0;33m'
BLUE='\033[0;34m'
PURPLE='\033[0;35m'
CYAN='\033[0;36m'
RESET='\033[0m'

# 打印标题
echo -e "${PURPLE}==========搭建私有仓库并上传JAVA:8-jre镜像===========${RESET}"

# 步骤1
echo -e "${BLUE}[1] 上传registry.tar至/opt目录下${RESET}"
wget -O /opt/registry.tar https://dlink.host/1drv/aHR0cHM6Ly8xZHJ2Lm1zL3UvcyFBaVlDNncwZHotYlJnUUZFRnlTQ0MxZEF3eTZrP2U9a0twdE54.tar

# 步骤2
echo -e "${BLUE}[2] 开启docker服务${RESET}"
systemctl start docker

# 步骤3
echo -e "${BLUE}[3] 导入镜像${RESET}"
docker load -i /opt/registry.tar

# 步骤4
echo -e "${BLUE}[4] 启动私有仓库容器${RESET}"
docker run -di --name=registry -p 5000:5000 registry

# 步骤5
echo -e "${BLUE}[5] 打开浏览器验证${RESET}"
echo -e "${YELLOW}输入地址http://${LOCAL_IP}:5000/v2/_catalog看到{"repositories":[]} 表示私有仓库搭建成功并且内容为空${RESET}"

# 步骤6
echo -e "${BLUE}[6] 修改daemon.json${RESET}"
printf '{"insecure-registries":["%s:5000"]}' "${LOCAL_IP}" > /etc/docker/daemon.json

# 步骤7
echo -e "${BLUE}[7] 重启docker服务${RESET}"
systemctl restart docker

# 步骤8
echo -e "${BLUE}[8] 上传java.tar至/opt目录下,导入镜像${RESET}"
wget -O /opt/java.tar https://dlink.host/1drv/aHR0cHM6Ly8xZHJ2Lm1zL3UvcyFBaVlDNncwZHotYlJnUUpzRm9OMmJaWDB2YVpmP2U9dEt6OUFl.tar
docker load -i /opt/java.tar

# 步骤9
echo -e "${BLUE}[9] 标记此镜像为私有仓库的镜像${RESET}"
docker tag 192.168.222.100:5000/java:8-jre ${LOCAL_IP}:5000/java:8-jre

# 步骤10
echo -e "${BLUE}[10] 再次启动私服容器${RESET}"
docker start registry

# 步骤11
echo -e "${BLUE}[11] 上传标记的镜像${RESET}"
docker push ${LOCAL_IP}:5000/java:8-jre

# 步骤12
echo -e "${BLUE}[12] 浏览器验证${RESET},${YELLOW}输入地址http://${LOCAL_IP}:5000/v2/_catalog"
echo -e "${GREEN}搭建私有仓库并上传JAVA:8-jre镜像成功!${RESET}"

环境都安装成功

JDK17

image-20240624190324668

MAVEN

image-20240624191136345

Docker_compose

image-20240624191254676

私有化仓库

image-20240625224325791

image-20240625231608008

第二步：代码环境准备

源码文件下载地址：https://fj.ly93.cc/16/1562681168/microservice.zip
（如果觉得这部分自己手动操作麻烦可以直接跳转到一键摆脱双手模式） 跳转

1.修改pom配置文件

全局替换pom文件里的私有仓库地址的IP地址为自己的IP地址

0d13bbbefe768d0e3469394a4281e04

2.四个子模块分别添加Dockerfile文件

①microservice-eureka-server

1
2
3
4
5
6
7
FROM 192.168.31.151:5000/java:8-jre
MAINTAINER sh <3300519161@qq.com>

ADD ./target/microservice-eureka-server-0.0.1-SNAPSHOT.jar /app/microservice-eureka-service.jar
CMD ["java", "-Xmx200m", "-jar", "/app/microservice-eureka-service.jar"]

EXPOSE 8761

②microservice-gateway-zuul

1
2
3
4
5
6
7
FROM 192.168.31.151:5000/java:8-jre
MAINTAINER sh <3300519161@qq.com>

ADD ./target/microservice-gateway-zuul-0.0.1-SNAPSHOT.jar /app/microservice-gateway-zuul.jar
CMD ["java", "-Xmx200m", "-jar", "/app/microservice-gateway-zuul.jar"]

EXPOSE 8050

③microservice-orderservice

1
2
3
4
5
6
7
FROM 192.168.31.151:5000/java:8-jre
MAINTAINER sh <3300519161@qq.com>

ADD ./target/microservice-orderservice-0.0.1-SNAPSHOT.jar /app/microservice-orderservice.jar
CMD ["java", "-Xmx200m", "-jar", "/app/microservice-orderservice.jar"]

EXPOSE 7900

④microservice-userservice

1
2
3
4
5
6
7
FROM 192.168.31.151:5000/java:8-jre
MAINTAINER sh <3300519161@qq.com>
ADD ./target/microservice-userservice-0.0.1-SNAPSHOT.jar \
     /app/microservice-userservice.jar
CMD ["java", "-Xmx200m", "-jar", "/app/microservice-userservice.jar"]

EXPOSE 8030

3.修改docker-compose.xml （替换成自己的IP地址以及数据库密码）

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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
version: "3"
services:
  mysql:
    image: mysql:5.6
    restart: on-failure
    ports:
      - 3306:3306
    volumes:
      - microservice-mysql:/var/lib/mysql
    networks:
      - microservice-net
    environment:
      MYSQL_ROOT_PASSWORD: 215830
      MYSQL_DATABASE: microservice_mallmanagement
    deploy:
      replicas: 1
      restart_policy:
        condition: on-failure
      placement:
        constraints: [node.role == manager]

  eureka-server:
    image: 192.168.31.151:5000/microservice-eureka-server:0.0.1-SNAPSHOT
    restart: on-failure
    ports:
      - 8761:8761
    networks:
      - microservice-net
    deploy:
      replicas: 1
      restart_policy:
        condition: on-failure

  gateway-zuul:
    image: 192.168.31.151:5000/microservice-gateway-zuul:0.0.1-SNAPSHOT
    restart: on-failure
    ports:
      - 8050:8050
    networks:
      - microservice-net
    depends_on:
      - eureka-server
    deploy:
      replicas: 1
      restart_policy:
        condition: on-failure
      placement:
        constraints: [node.role == manager]

  order-service:
    image: 192.168.31.151:5000/microservice-orderservice:0.0.1-SNAPSHOT
    restart: on-failure
    ports:
      - 7900:7900
    networks:
      - microservice-net
    depends_on:
      - mysql
      - eureka-server
    deploy:
      replicas: 2
      restart_policy:
        condition: on-failure

  user-service:
    image: 192.168.31.151:5000/microservice-userservice:0.0.1-SNAPSHOT
    restart: on-failure
    ports:
      - 8030:8030
    networks:
      - microservice-net
    depends_on:
      - mysql
      - eureka-server
    deploy:
      replicas: 2
      restart_policy:
        condition: on-failure

  visualizer:
    image: dockersamples/visualizer:stable
    ports:
      - 8081:8080
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    deploy:
      placement:
        constraints: [node.role == manager]
    networks:
      - microservice-net

networks:
  microservice-net:
volumes:
  microservice-mysql:

4.将源码文件打包上传虚拟机

利用虚拟机里面的maven工具构建镜像。

1
2
mkdir /micreservice
cd /micreservice

2b0d720b50d20c0797fb2ac29b43d07

利用maven工具构建镜像脚本

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
#!/bin/bash

# 获取本机静态 IP 地址
LOCAL_IP=$(hostname -I | awk '{print $1}')

# 彩色输出函数
print_color() {
    echo -e "\033[${1}m${2}\033[0m"
}

# 创建目录
print_color "34" "1、创建目录 /microservice"
mkdir /microservice
cd /microservice

# 上传压缩包
print_color "34" "2、上传 microservice.zip 至 /microservice 目录"
# 这里需要手动上传 microservice.zip 压缩包

# 解压文件
print_color "34" "3、解压 microservice.zip"
if ! command -v unzip &> /dev/null; then
    print_color "33" "未安装 unzip,正在安装..."
    yum -y install unzip
fi
unzip microservice.zip

#进入解压文件夹
printf "${YELLOW}切入microservice-mallmanagement文件夹。。。${NC}\n"
cd microservice-mallmanagement

# 设置 Maven 使用阿里云镜像源
printf "${YELLOW}设置 Maven 使用阿里云镜像源...${NC}\n"
mvn mirror:go -Dmirror.url=https://maven.aliyun.com/repository/public

# 构建镜像
print_color "34" "4、进入 microservice 目录并构建镜像"
cd microservice
mvn install

# 验证结果
print_color "34" "5、验证构建结果"
print_color "32" "访问 http://${LOCAL_IP}:5000/v2/_catalog 查看镜像库"

一键化脚本彻底摆脱双手操作

MAINTAINER sh 3300519161@qq.com 替换成自己的信息，随便什么这里是写作者的信息的。。。

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
67
68
69
70
71
72
73
74
#!/bin/bash

# 定义颜色变量
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[0;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# 获取本机 IP 地址
LOCAL_IP=$(hostname -I | awk '{print $1}')

# 打印开始信息
printf "${GREEN}开始执行脚本...${NC}\n"

# 创建 microservice 目录并进入
printf "${YELLOW}创建 microservice 目录...${NC}\n"
mkdir -p /microservice
cd /microservice

# 下载源码文件
printf "${YELLOW}下载源码文件...${NC}\n"
wget https://fj.ly93.cc/16/1562883351/microservice.zip

# 检查是否安装了 unzip 工具
if ! command -v unzip &> /dev/null; then
    printf "${YELLOW}未安装 unzip 工具,开始安装...${NC}\n"
    sudo yum install -y unzip
fi

# 解压源码文件
printf "${YELLOW}解压源码文件...${NC}\n"
unzip microservice.zip

# 进入解压文件夹
printf "${YELLOW}切入 microservice-mallmanagement 文件夹...${NC}\n"
cd microservice-mallmanagement

# 替换 pom.xml 文件中的 IP 地址
printf "${YELLOW}替换 pom.xml 文件中的 IP 地址...${NC}\n"
sed -i "s/192.168.31.151/$LOCAL_IP/g" microservice-eureka-server/pom.xml
sed -i "s/192.168.31.151/$LOCAL_IP/g" microservice-gateway-zuul/pom.xml
sed -i "s/192.168.31.151/$LOCAL_IP/g" microservice-orderservice/pom.xml
sed -i "s/192.168.31.151/$LOCAL_IP/g" microservice-userservice/pom.xml

# 修改 Dockerfile 文件中的 IP 地址
printf "${YELLOW}修改 Dockerfile 文件中的 IP 地址...${NC}\n"
sed -i "s/192.168.31.151/$LOCAL_IP/g" microservice-eureka-server/Dockerfile
sed -i "s/192.168.31.151/$LOCAL_IP/g" microservice-gateway-zuul/Dockerfile
sed -i "s/192.168.31.151/$LOCAL_IP/g" microservice-orderservice/Dockerfile
sed -i "s/192.168.31.151/$LOCAL_IP/g" microservice-userservice/Dockerfile

# 替换 docker-compose.yml 文件中的 IP 地址
printf "${YELLOW}替换 docker-compose.yml 文件中的 IP 地址...${NC}\n"
sed -i "s/192.168.31.151/$LOCAL_IP/g" docker-compose.yml

# 替换 docker-compose-swarm.yml 文件中的 IP 地址
printf "${YELLOW}替换 docker-compose-swarm.yml 文件中的 IP 地址...${NC}\n"
sed -i "s/192.168.31.151/$LOCAL_IP/g" docker-compose-swarm.yml

# 设置 Maven 使用阿里云镜像源
printf "${YELLOW}设置 Maven 使用阿里云镜像源...${NC}\n"
mvn mirror:go -Dmirror.url=https://maven.aliyun.com/repository/public

# 构建镜像
printf "${YELLOW}开始构建镜像...${NC}\n"
mvn clean install -Dmaven.test.skip=true

# 验证镜像库
printf "${GREEN}验证镜像库...${NC}\n"
curl http://$LOCAL_IP:5000/v2/_catalog

printf "${GREEN}脚本执行完成！${NC}\n"

验证成功：

image-20240626014840148

image-20240626010025515

第三步：使用docker-compose工具启动项目

老样子使用shell脚本构建

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
67
68
69
70
71
72
73
74
75
76
77
78
#!/bin/bash

# 获取本机IP地址
LOCAL_IP=$(hostname -I | awk '{print $1}')

# 设置颜色变量
RED='\033[0;31m'
GREEN='\033[0;32m'
BLUE='\033[0;34m'
NC='\033[0m' # 无颜色

# 下载MySQL镜像
printf "${BLUE}下载MySQL镜像...${NC}\n"
wget -O /opt/mysql.tar https://fj.ly93.cc/16/1562156665/mysql.tar
if [ $? -eq 0 ]; then
    printf "${GREEN}MySQL镜像下载成功!${NC}\n\n"
else
    printf "${RED}MySQL镜像下载失败,请检查网络连接。${NC}\n"
    exit 1
fi

# 导入MySQL镜像
printf "${BLUE}导入MySQL镜像...${NC}\n"
docker load -i /opt/mysql.tar
printf "${GREEN}MySQL镜像导入成功!${NC}\n\n"

echo -e "${BLUE}标记此镜像为私有仓库的镜像${RESET}"
docker tag mysql:5.6 ${LOCAL_IP}:5000/mysql:5.6

# 步骤10
echo -e "${BLUE}再次启动私服容器${RESET}"
docker start registry

# 步骤11
echo -e "${BLUE}上传标记的镜像${RESET}"
docker push ${LOCAL_IP}:5000/mysql:5.6

# 下载Visualizer镜像
printf "${BLUE}下载Visualizer镜像...${NC}\n"
wget -O /opt/visualizer.tar https://fj.ly93.cc/16/1563405042/visualizer.tar
if [ $? -eq 0 ]; then
    printf "${GREEN}Visualizer镜像下载成功!${NC}\n\n"
else
    printf "${RED}Visualizer镜像下载失败,请检查网络连接。${NC}\n"
    exit 1
fi

# 导入Visualizer镜像
printf "${BLUE}导入Visualizer镜像...${NC}\n"
docker load -i /opt/visualizer.tar
printf "${GREEN}Visualizer镜像导入成功!${NC}\n\n"

echo -e "${BLUE}标记此镜像为私有仓库的镜像${RESET}"
docker tag dockersamples/visualizer:stable ${LOCAL_IP}:5000/dockersamples/visualizer:stable

# 上传Visualizer镜像
echo -e "${BLUE}上传Visualizer镜像${RESET}"
docker push ${LOCAL_IP}:5000/dockersamples/visualizer:stable

# 替换 docker-compose.yml 文件中的 mysql:5.6 和 dockersamples/visualizer:stable
sed -i "s|mysql:5.6|${LOCAL_IP}:5000/mysql:5.6|g" /microservice/microservice-mallmanagement/docker-compose.yml
sed -i "s|dockersamples/visualizer:stable|${LOCAL_IP}:5000/dockersamples/visualizer:stable|g" /microservice/microservice-mallmanagement/docker-compose.yml

# 进入项目目录并启动Docker Compose
printf "${BLUE}进入项目目录并启动Docker Compose...${NC}\n"
cd /microservice/microservice-mallmanagement
docker-compose up -d
printf "${GREEN}Docker Compose启动成功!${NC}\n\n"

# 查看容器状态
printf "${BLUE}查看容器状态...${NC}\n"
docker ps
printf "${GREEN}容器已成功启动!${NC}\n\n"

# 浏览器访问
printf "${BLUE}浏览器访问: http://${LOCAL_IP}:8761${NC}\n"
printf "${GREEN}请在浏览器中访问上述链接,验证是否成功启动。${NC}\n"

启动成功：

image-20240626022321985

image-20240626022421016

第四步：构建gogs+jenkins实现自动化部署

1.先删除之前构建的镜像以及docker-compose容器

①停止并删除运行容器

1
2
docker stop $(docker ps -aq)
docker rm $(docker ps -aq)

②删除其他有关microservice的镜像

1
2
#删除命令
docker rmi [IMAGE ID]

image-20240626023420650

2.重新启动私有仓库容器并上传java:jre-8

1
2
docker run -di --name=registry -p 5000:5000 registry
docker push 192.168.31.151:5000/java:8-jre  #注意替换IP

第五步：搭建gogs服务器（可再开一台机子【sh2】）

①导入gogs镜像

1
2
3
cd /opt
wget https://fj.ly93.cc/16/1562400565/gogs.tar 
docker load -i /opt/gogs.tar

②启动容器

1
docker run -d -p 10022:22 -p 13000:3000 -v /var/gogs:/data gogs/gogs

③浏览器访问ip:13000，进行初始化设置

注意IP地址替换成二机的其他端口自定义

image-20240626031534758

image-20240626025706260

④配置好后点击立即安装

第六步：创建仓库并上传代码

① 创建仓库

image-20240626025907845

image-20240626030005074

image-20240626030633762

②回到sh1机子上传代码

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
#!/bin/bash

# 安装git
yum install -y git

# 切换到项目目录
cd /microservice/microservice-mallmanagement

#移除原先存在的.git文件
rm -rf .git
# 初始化git仓库
git init

# 添加所有文件到暂存区
git add .

# 设置全局用户名
git config --global user.name "root"

# 设置全局电子邮件地址
git config --global user.email "root@qq.com"

# 提交更改，附带提交信息
git commit -m "first commit"

# 添加远程仓库，注意这里的git地址是上面上传项目生成的地址！
git remote add origin http://192.168.31.152:13000/root/microservice.git

# 推送代码到远程仓库的master分支，并设置默认上游分支
git push -u origin master

# 如果需要验证密码，请输入管理员账号密码,账号密码就是刚才创建的管理员账号密码


提交成功

image-20240626032258194

image-20240626032315748

第七步：构建jenkins（sh1）

①jenkins准备

1
2
3
4
5
6
#创建jenkins目录
mkdir /opt/jenkins
cd /opt/jenkins
#下载jenkins.war文件
wget -O jenkins.war https://dlink.host/1drv/aHR0cHM6Ly8xZHJ2Lm1zL3UvcyFBaVlDNncwZHotYlJlc3preXI4cG5FSVZ6VlU_ZT1pZ3E3N3Y.war #提权
chmod +x /opt/jenkins/jenkins.war

②启动jenkiins

1
2
3
4
5
6
#下载字体库
yum install dejavu-sans-fonts -y
yum install fontconfig -y
fc-cache --force
#原神启动
java -jar /opt/jenkins/jenkins.war --httpPort=9090

④浏览器访问 http://你的IP:9090/

运行完后会生成密码

image-20240626033547246

⑤将生成的密码贴入首页

image-20240626033615850

⑥选择插件安装

image-20240626033712004

⑦选择”无“，然后安装

image-20240626033750382

⑧创建用户-点击保存并完成

image-20240626033818236

⑨实例配置-点击现在不要

image-20240626033917776

⑩开始使用jenkins

image-20240626033945364

第八步：安装插件

①首页点击Manager Jenkins

image-20240626034048170

②安装插件

image-20240626034112507

③换清华源

1
https://mirrors.tuna.tsinghua.edu.cn/jenkins/updates/update-center.json

image-20240626034224934

④安装maven插件

image-20240626034326718

image-20240626034543149

⑤安装git

image-20240626034626357

⑥配置Java环境和Mvn环境

image-20240626035029246

image-20240626035211324

⑦创建工程

image-20240626035244495

image-20240626035303926

image-20240626035354986

image-20240626035430046

image-20240626035452855

1
docker-compose up -d

⑧保存退出

第九步：构建项目

①构建项目

image-20240626035556266

②查看控制台输出

image-20240626035633888

image-20240626041446556

③构建成功

image-20240626040911373

④访问 IP：8761 验证

image-20240626040947433

image-20240626042443503

简约, 白色, 黑色的, 大海, 风波 壁纸 4857x3238 允许