# 需求是：实现跨平台批量打包发布

jenkins pip流水线+xshell

## jenkins pip

```
def createVersion() {
    // 定义一个版本号作为当次构建的版本，输出结果 年月日_构建ID
    return new Date().format('yyyyMMdd') + "_${env.BUILD_ID}"
}

pipeline {
    agent any
    
    // 在 environment 引入上边定义的函数，以便于全局调用
    environment {
        VERSION = createVersion()
        PROJECT = "single-enroll"
        ENV = "zou-edu-api-prod"
        JAR_PATH = "${PROJECT}/target"
        SERVER_LIST = "xxx,xxxx"
    }

    stages {
        stage('拉取代码') {
            steps {
                git branch: "${branch}", credentialsId: 'c1f395ca-d3db-45de-a345-b1613edbffda', url: 'http://101.69.246.86:18099/zjlll/single-enroll.git'
            }
        }

        stage('传输编译') {
            steps {
                script {
                    // 在这里使用双引号以进行变量插值，确保变量被正确替换
                    sh "/deploy/app/${ENV}/bin/jdk_1.8scp.sh ${PROJECT} ${VERSION} '${SERVER_LIST}' ${ENV}"
                }
            }
        }

        stage('版本信息') {
            steps {
                script {
                    sh "echo 版本信息 ==========   \${VERSION}"
                }
            }
        }
    }
}
```
## shell 
jdk_1.8scp.sh
```
#!/bin/bash

PROJECT=$1
VERSION=$2
SERVER_LIST=$3
ENV=$4

echo "开始打包 ${PROJECT} ${VERSION}"

# 打包项目
tar -czf ${VERSION}${PROJECT}.tar.gz .

# 传输到服务器列表中的每个服务器
for server in $(echo ${SERVER_LIST} | tr ',' ' '); do
    echo "传输到 ${server}..."

    # 使用 ssh 命令检查目标目录是否存在，不存在则创建目录
    ssh root@${server} << EOF
        if [ ! -d "/deploy/app/${ENV}/${PROJECT}/bak" ]; then
            mkdir -p /deploy/app/${ENV}/${PROJECT}/bak
        fi
        if [ ! -d "/deploy/app/${ENV}/${PROJECT}/build" ]; then
            mkdir -p /deploy/app/${ENV}/${PROJECT}/build
        fi
        if [ ! -d "/deploy/app/${ENV}/${PROJECT}/run" ]; then
            mkdir -p /deploy/app/${ENV}/${PROJECT}/run
        fi
EOF

    # 检查目录是否成功创建，如果创建失败则报错并退出
    if [ $? -ne 0 ]; then
        echo "无法在 ${server} 上创建目录 /deploy/app/${ENV}/${PROJECT}/bak 或 /deploy/app/${ENV}/${PROJECT}/build 或 /deploy/app/${ENV}/${PROJECT}/run"
        exit 1
    fi

    # 传输文件到目标服务器的目录
    scp ${VERSION}${PROJECT}.tar.gz root@${server}:/deploy/app/${ENV}/${PROJECT}/bak/

    # 在目标服务器上解压文件并执行 Maven 构建
    ssh root@${server} << EOF
        tar -xzf /deploy/app/${ENV}/${PROJECT}/bak/${VERSION}${PROJECT}.tar.gz -C /deploy/app/${ENV}/${PROJECT}/build
        cd /deploy/app/${ENV}/${PROJECT}/build && mvn install
EOF

    # 检查 Maven 构建结果并记录日志
    if [ $? -eq 0 ]; then
        echo "在 ${server} 上执行 Maven 构建成功."
    else
        echo "在 ${server} 上执行 Maven 构建失败."
        # 可添加额外的处理逻辑，如退出脚本或记录错误
    fi

    # 备份最近10份，超过就删除掉
    ssh root@${server} << EOF
        cd /deploy/app/${ENV}/${PROJECT}/bak
        files=(\$(ls -t))
        file_count=\${#files[@]}
        if [ \$file_count -gt 10 ]; then
            files_to_delete=\${files[@]:10}
            for file in \${files_to_delete}; do
                rm -f \$file
            done
        fi
EOF

    # 清空并移动 target 发布文件
    ssh root@${server} << EOF
        rm -rf /deploy/app/${ENV}/${PROJECT}/run/*.jar
        mv /deploy/app/${ENV}/${PROJECT}/build/target/${PROJECT}.jar /deploy/app/${ENV}/${PROJECT}/run/
        rm -rf /deploy/app/${ENV}/${PROJECT}/build/*
EOF

    # 使用 supervisor 启动应用程序
    ssh root@${server} << EOF
        supervisorctl status
        supervisorctl restart single-enroll
        sleep 10
        supervisorctl status
EOF
done

# 删除本服务器目录下文件（请谨慎执行）
rm -rf /var/lib/docker/jenkins2/workspace/zou-edu-api-prod/single-enroll/*

echo "打包和传输完成"
```


## jenkins密钥反编译
密钥为

```
{AQAAABAAAAAgXontB+gAfa94Z2bn/64aYbsS9MxCEIYZq+h1DQcmTugt45nvAOq5l1TigGA}
```
去jenkins---系统管理-终端-执行代码----反编译代码为
```
import hudson.util.Secret

// 替换为从 hudson.util.Secret 文件中提取的加密字符串
def encryptedString = '{AQAAABAAAAAgXontB+gAfa94Z2bn/64aYbsS9MxCEIYZq+h1DQcmTugt45nvAOq5l1TigGA}'

// 解密密钥字符串
def decryptedString = Secret.fromString(encryptedString).getPlainText()

// 打印解密后的字符串
println("Decrypted String: " + decryptedString)
```



## build-api.sh 

```
#!/bin/bash

SERVER_LIST=$1
VERSION=$2
PROJECT=$3
JAR_PATH=$4
ENV=$5
BAK_DIR="/deploy/app/${ENV}/bak/${PROJECT}/"


publish(){
 
         if [ -f "${JAR_PATH}/${PROJECT}.jar" ]; then
               echo 'jar包文件存在,执行发布流程'

 	       #发送jar包到节点服务器
	       scp ${JAR_PATH}/${PROJECT}.jar root@$1:/deploy/app/${ENV}/jar
               scp ${JAR_PATH}/${PROJECT}.jar root@$1:/deploy/app/${ENV}/bak/${PROJECT}/${PROJECT}-${VERSION}.jar              
ssh -T $1 << EOF

             echo '=====在【'$1'】节点执行更新操作======'
             supervisorctl restart ${PROJECT}
 
	     if [ ! -d  "${BAK_DIR}"  ]; then
        	 echo '无对应备份目录...执行创建操作,发布失败'
                 mkdir -p ${BAK_DIR}
                 exit 1 
	     else
                   cd ${BAK_DIR}
        	   echo '保留10个最新的备份'
	           find ${BAK_DIR} -type f -printf '%T@ %p\n' | sort -nr | tail -n +11 | cut -d' ' -f2- | xargs rm -rf
   	  fi
		exit
EOF
            else
               echo 'jar包文件不存在'
         fi
}
IFS=","
arr=($SERVER_LIST)
for server_ip in ${SERVER_LIST[@]}
do
  publish $server_ip
done
```

## build-web.sh 

```
#!/bin/bash

SERVER_LIST=$1
VERSION=$2
PROJECT=$3
STATIC_PATH=$4
ENV=$5
BAK_DIR="/deploy/app/${PROJECT}/bak/"
publish(){
 
         if [ -f "${STATIC_PATH}/${PROJECT}.tar.gz" ]; then
               echo '静态资源包文件存在,执行发布流程'

 	       #发送包到节点服务器
	       scp ${STATIC_PATH}/${PROJECT}.tar.gz root@$1:/deploy/app/${PROJECT}/bak/${PROJECT}-${VERSION}.tar.gz
 
ssh -T $1 << EOF

             echo '=====在【'$1'】节点执行更新操作======'
 
	     if [ ! -d  "${BAK_DIR}"  ]; then
        	 echo '无对应备份目录...执行创建操作,发布未成功'
                 mkdir -p ${BAK_DIR}
                 exit 1
	     else
                   cd ${BAK_DIR}
                   tar -zxf ${PROJECT}-${VERSION}.tar.gz
                   
                   rm -rf ../dist
                   mv ./dist ../  
                 
        	   echo '保留10个最新的备份'
	           find ${BAK_DIR} -type f -printf '%T@ %p\n' | sort -nr | tail -n +11 | cut -d' ' -f2- | xargs rm -rf
   	  fi
		exit
EOF
            else
               echo '静态文件包包文件不存在'
         fi
}
IFS=","
arr=($SERVER_LIST)
for server_ip in ${SERVER_LIST[@]}
do
  publish $server_ip
done
```

##

jenkins

## 简介
ncdu 是一个在Linux系统下使用终端界面来分析磁盘使用情况的命令行工具。它可以快速扫描目录，并统计该目录下的文件和文件夹的磁盘使用情况，以可读性强且交互友好的方式呈现给用户。
## 安装

```
yum install ncdu
```


## 使用方法
要使用 ncdu 运行一个扫描任务，只需在终端中使用 ncdu 命令，后面加上要扫描的目录的路径：

```
ncdu /path/to/directory
```
这将启动 ncdu 并开始扫描目标目录。扫描完成后，将显示一个交互式界面，列出目录中各个文件和文件夹的磁盘使用量。

磁盘管理工具ncdu

:::info{title="简介"}

基于Cloudflare Workers 搭建 Docker Hub镜像加速服务。
:::

前置条件


:::warning{title="没有这些就不要往下看了"}
首先要注册一个Cloudflare账号。

Cloudflare账号下域名的一级域名，推荐万网注册个top域名，再转移到Cloudflare，很便宜的。（没有也无所吊慰，有免费域名，只是慢点而已）

注意 Worker 每天每免费账号有次数限制，为10万次。每分钟为1000次。
:::

## 步骤
登录到CF的仪表盘 https://dash.cloudflare.com/

点击 workers-and-pages > 创建应用程序 > 创建 Worker > 点击保存 >点击完成 > 编辑代码


#### 没有注册的可以先注册，登陆后安装图文指引进行
![image.png](/static/img/2e4ed783081253451540cabe73676f9a.image.webp)



#### 为项目命名
![image.png](/static/img/0545fae9c4b8fba121941de2149ad838.image.webp)

#### 编写代码导入其中
![image.png](/static/img/66df882a49fbcaee13b5fb3cba35bf83.image.webp)

```
import HTML from './docker.html';
export default {
    async fetch(request) {
        const url = new URL(request.url);
        const path = url.pathname;
        const originalHost = request.headers.get("host");
        const registryHost = "registry-1.docker.io";
        if (path.startsWith("/v2/")) {
        const headers = new Headers(request.headers);
        headers.set("host", registryHost);
        const registryUrl = `https://${registryHost}${path}`;
        const registryRequest = new Request(registryUrl, {
            method: request.method,
            headers: headers,
            body: request.body,
            // redirect: "manual",
            redirect: "follow",
        });
        const registryResponse = await fetch(registryRequest);
        console.log(registryResponse.status);
        const responseHeaders = new Headers(registryResponse.headers);
        responseHeaders.set("access-control-allow-origin", originalHost);
        responseHeaders.set("access-control-allow-headers", "Authorization");
        return new Response(registryResponse.body, {
            status: registryResponse.status,
            statusText: registryResponse.statusText,
            headers: responseHeaders,
        });
        } else {
        return new Response(HTML.replace(/{{host}}/g, originalHost), {
            status: 200,
            headers: {
            "content-type": "text/html"
            }
        });
        }
    }
}
```
点击新建文件 **docker.html**，创建此文件。ctrl + s 即可保存。
![image.png](/static/img/addbf7445a0f76837eab60a9a4cb2a48.image.webp)
```
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>镜像使用说明</title>
    <style>
        body {
            font-family: 'Roboto', sans-serif;
            margin: 0;
            padding: 0;
            background-color: #f4f4f4;
        }
        .header {
            background: linear-gradient(135deg, #667eea, #764ba2);
            color: #fff;
            padding: 20px 0;
            text-align: center;
            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
        }
        .container {
            max-width: 800px;
            margin: 40px auto;
            padding: 20px;
            background-color: #fff;
            box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
            border-radius: 10px;
        }
        .content {
            margin-bottom: 20px;
        }
        .footer {
            text-align: center;
            padding: 20px 0;
            background-color: #333;
            color: #fff;
        }
        pre {
            background-color: #272822;
            color: #f8f8f2;
            padding: 15px;
            border-radius: 5px;
            overflow-x: auto;
        }
        code {
            font-family: 'Source Code Pro', monospace;
        }
        a {
            color: #4CAF50;
            text-decoration: none;
        }
        a:hover {
            text-decoration: underline;
        }
        @media (max-width: 600px) {
            .container {
                margin: 20px;
                padding: 15px;
            }
            .header {
                padding: 15px 0;
            }
        }
    </style>
    <link href="https://fonts.googleapis.com/css2?family=Roboto:wght@400;700&family=Source+Code+Pro:wght@400;700&display=swap" rel="stylesheet">
</head>
<body>
    <div class="header">
        <h1>镜像使用说明</h1>
    </div>
    <div class="container">
        <div class="content">
            <p>为了加速镜像拉取，你可以使用以下命令设置 registry mirror:</p>
            <pre><code>sudo tee /etc/docker/daemon.json &lt;&lt;EOF
{
    "registry-mirrors": ["https://{{host}}"]
}
EOF</code></pre>
            <p>为了避免 Worker 用量耗尽，你可以手动 pull 镜像然后 re-tag 之后 push 至本地镜像仓库:</p>
            <pre><code>docker pull {{host}}/library/alpine:latest # 拉取 library 镜像
docker pull {{host}}/coredns/coredns:latest # 拉取 coredns 镜像</code></pre>
        </div>
    </div>
    <div class="footer">
        <p>Powered by Cloudflare Workers</p>
        <p><a href="https://songxwn.com" target="_blank">访问博客 songxwn.com</a></p>
    </div>
</body>
</html>

```
#### 保存部署并配置触发器
上述两个文件的代码保存后，选择部署 > 保存并部署

点击左上角的项目连接，配置触发器。（自定义域名访问）


![image.png](/static/img/001710407ccbc2dfbb08aaf694ba6c48.image.webp)


## 效果图
https://rapid-pond-fa49.2467802439.workers.dev/

![image.png](/static/img/686395e65c2545cf560fa218b4d34355.image.webp)

基于Cloudflare Workers 搭建 Docker Hub 镜像加速

# 云服务器初始化操作
## 拉取最新包

```
yum update
```
## 安装 EPEL 软件源，包含了大量的额外软件包
```
yum install -y epel-release
```
## 关闭防火墙和selinux

```
关闭防火墙
[root@localhost ~]$ systemctl stop firewalld
永久关闭防火墙
[root@localhost ~]$ systemctl disable firewalld
[root@localhost ~]$ setenforce 0
禁用selinux
[root@localhost ~]$ sed -i 's#SELINUX=enforcing#SELINUX=disabled#g' /etc/selinux/config
```
##  检查防火墙 selinux

```
systemctl status firewalld
```

![image.png](/static/img/69e29a3a4ad90674ffc49ac111698246.image.webp)

##  yum源
### 把源修改为阿里云或其他国内的源，会加快源下载速度

```
#修改base源 为阿里云
curl -o /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-7.repo
#增加epel源
curl -o /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
```
## 安装常用工具

```
这就是我们一次下载多个常用的工具，就像给windows系统安装多个软件一样

yum install -y vim tree  wget bash-completion bash-completion-extras lsof lrzsz net-tools sysstat iotop iftophtop unzip nc nmap telnet bc psmisc httpd-tools bind-utils nethogs expect ntpdate
 mkdir -p /app/tools  /app/code
```
# 优化ssh连接速度

```
sed -i '/^GSSAPIAuthentication/s@^@#@g' /etc/ssh/sshd_config
cat >>/etc/ssh/sshd_config<<EOF
UseDNS no
GSSAPIAuthentication no
EOF
systemctl restart sshd
#检查
egrep '^(GSSAPIAuthentication|UseDNS)' /etc/ssh/sshd_config
```
# 时间同步

```
yum install -y ntp
service ntpd start
```
# 命令行颜色

```
#写入到/etc/profile中即可
echo export PS1="'[\[\e[34;1m\]\u@\[\e[0m\]\[\e[32;1m\]\h\[\e[0m\]\[\e[31;1m\] \w\[\e[0m\]]\$ '">> /etc/profile 
source /etc/profile
```


## 安装htop和ncdu

```
yum install -y htop ncdu
```


### vm克隆批量脚本
```
脚本用法
[root@localhost ~]$ mkdir -p /server/scripts
cat > /server/scripts/change.sh << 'EOF'
#!/bin/bash
#author: 作者
#desc: 修改系统IP地址和主机名
#version: v1.0

# 检查参数数量，如果参数数量不等于2，则输出用法信息并退出
if [ "$#" -ne 2 ]; then
  echo "Usage: $0 <new_hostname> <new_ip_last_part>"
  exit 1
fi

# 获取当前系统的IP地址的最后一部分
# hostname -I 显示所有IP地址
# awk '{print $1}' 选择第一个IP地址
# sed 's#.*\.##g' 只保留最后一部分
ip=$(hostname -I | awk '{print $1}' | sed 's#.*\.##g')

# 获取新的IP地址的最后一部分（作为参数传递）
ip_new=$2

# 获取新的主机名（作为参数传递）
hostname=$1

# 修改网卡配置文件中的IP地址
# 使用sed命令进行替换，将旧的IP地址替换为新的IP地址
sed -i "s#192.168.10.$ip#192.168.10.$ip_new#g" /etc/sysconfig/network-scripts/ifcfg-ens33

# 重启网络服务，以应用新的IP地址配置
systemctl restart network

# 修改主机名
hostnamectl set-hostname $hostname

# 输出修改结果，确认IP地址和主机名已经被修改
echo "IP地址已修改为：192.168.10.$ip_new"
echo "主机名已修改为：$hostname"
EOF
```
## 用法
```
/server/scripts/change.sh new-hostname 123
```
## 拆分命令-数据流向与脚本工作原理

输入参数
脚本接收两个输入参数：
	1	新的主机名 ($1)
	2	新的 IP 地址的最后一部分 ($2)
        
步骤 1: 检查参数数量
脚本首先检查传入的参数数量是否等于 2。如果参数数量不正确，脚本会输出用法信息并退出。

步骤 2: 获取当前 IP 地址的最后一部分
使用 hostname -I 获取当前主机的 IP 地址。这个命令返回所有 IP 地址。通过 awk '{print $1}' 选择第一个 IP 地址。然后，使用 sed 's#.*\.##g' 提取该 IP 地址的最后一部分。例如，如果 IP 地址是 192.168.10.100，则提取 100。

```
ip=$(hostname -I | awk '{print $1}' | sed 's#.*\.##g')
```
步骤 3: 获取新的 IP 地址的最后一部分
从传入的参数中获取新的 IP 地址的最后一部分，并赋值给 ip_new。
```
ip_new=$2
```
步骤 4: 获取新的主机名
从传入的参数中获取新的主机名，并赋值给 hostname。
```
hostname=$1
```
步骤 5: 修改网卡配置文件中的 IP 地址
使用 sed 命令在 /etc/sysconfig/network-scripts/ifcfg-eth33 文件中替换旧的 IP 地址部分（例如 192.168.10.100）为新的 IP 地址部分（例如 192.168.10.123）。

```
sed -i "s#192.168.10.$ip#192.168.10.$ip_new#g" /etc/sysconfig/network-scripts/ifcfg-eth33
```
步骤 6: 重启网络服务
重启网络服务，以应用新的 IP 地址配置。

```
systemctl restart network
```
步骤 7: 修改主机名
使用 hostnamectl set-hostname 命令修改主机名。

```
hostnamectl set-hostname $hostname
```

步骤 8: 输出修改结果
最后，输出新的 IP 地址和主机名，以确认修改已经生效。

```
echo "IP地址已修改为：192.168.10.$ip_new"
echo "主机名已修改为：$hostname"
```

云服务器初始化

# 加速一切镜像,当前只更新docker部分

[点击打开官网](https://github.com/DaoCloud/public-image-mirror?tab=readme-ov-file#单次单镜像同步)

# 操作流程
### 1.1
docker镜像加速，加入这个地址

```
{
  "registry-mirrors": [
    "https://docker.m.daocloud.io"
  ]
}
```
### 1.2
[点开链接，填入需要拉取的镜像](https://github.com/DaoCloud/public-image-mirror/issues/new?labels=sync+image&template=sync-image.yml)

### 1.3 输入完之后点击submit new issus确认
![image.png](/static/img/80fede2a0a74a2805916b498543be20f.image.webp)

### 1.4 点击详情请查看，可以看到拉取状态
![image.png](/static/img/5c2963bc3768d2295e75ec4067aaef8d.image.webp)
### 1.5 拉取状态会变成success

![image.png](http://115.29.205.107/static/img/91fa376da049256ce66c8af21c4df5e0.image.webp)

### 打开终端，进行拉取
命令为

```
docker pull m.daocloud.io/docker.io/jason5ng32/myip:latest
```