本页自动汇总「1运维」分类下的全部笔记（含子分类），随笔记增删实时更新。

wget https://repo.anaconda.com/archive/Anaconda3-2021.05-Linux-x86_64.sh

2.执行脚本

下载完成后，在终端中进入包所在的目录，并执行以下命令：

bash Anaconda3-2021.05-Linux-x86_64.sh

3.按照提示进行安装

然后，按照提示进行安装。在安装过程中需要输入一些信息，例如安装路径、是否将 Anaconda 添加到 PATH 环境变量中等。

4.激活 Anaconda 环境

安装完成后，需要激活 Anaconda 环境。在终端中输入以下命令：

source ~/anaconda3/bin/activate

5.验证 Anaconda 是否正确安装

最后，可以验证 Anaconda 是否正确安装。在终端中输入以下命令：

conda --version

如果显示了 Anaconda 的版本号，则说明 Anaconda 安装成功。
注意：在使用 Anaconda 之前，最好先更新一下 conda 和 Anaconda 自带的包管理器 pip，可以使用以下命令：

conda update conda
conda update anaconda
pip install --upgrade pip

CentOS 7.0默认使用的是firewall作为防火墙， 使用systemctl来管理服务和程序，包括了service和chkconfig

1、检查是否已安装防火墙

yum install firewalld firewall-config

2、查看默认防火墙状态（开启后显示running，关闭后显示not running）

firewall-cmd --state

3、检查防火墙的状态（enabled表示正常运行，disabled表示防火墙已经关闭）

systemctl list-unit-files|grep firewalld.service

4、开启防火墙

systemctl start firewalld.service  		--启动firewall
systemctl enable firewalld.service		--开机时启动firewall

5、关闭防火墙

systemctl stop firewalld.service    		--停止firewall
systemctl disable firewalld.service		--禁止firewall开机启动

6、重启防火墙

systemctl restart firewalld.service

7、查看防火墙是否开机自启（enabled表示自启，disabled表示不自启）

systemctl is-enabled firewalld.service;echo $?

8、查看已启动的服务列表

systemctl list-unit-files|grep enabled

9、开启端口

# 这里开启的是80端口，开启其他端口可自定义
firewall-cmd --zone=public --add-port=80/tcp --permanent
# 开启之后一定要重启一下防火墙，不然不生效！！！
firewall-cmd --reload  
# 命令含义：
–zone #作用域
–add-port=80/tcp #添加端口，格式为：端口/通讯协议
–permanent #永久生效，没有此参数重启后失效

10、查看已经开放的端口

firewall-cmd --permanent --list-port

11、屏蔽FirewallD服务

systemctl mask firewalld

12、反屏蔽FirewallD服务

# 这是反屏蔽FirewallD服务，它会移除屏蔽FirewallD服务时创建的符号链接，故能重新启用服务。（主要针对上面第4点的开机自启服务）
systemctl unmask firewalld

问题：缺少插件​Maven Intergration

解决：

1.进入系统管理

2.点击插件管理

3.选择可选插件

4.搜索Maven（因我已安装）

两种方式
① 第一种
用netstat -ano | grep 端口 找出进程号

然后 kill -9 进程号 杀进程
② 第二种

例：关闭占用80端口的进程

sudo fuser -k -n tcp 80

Jenkins构建项目并运行的流程如下

Git：我用的yum安装

# Ubuntu
apt-get install git
# Centos 
yum install git
git --version

Jenkins：注意的是Jenkins 宣布：从2020年6月28日发布的 Jenkins 2.357 和即将发布的 9 月 LTS 版本开始，Jenkins 最低需要 Java 11。
所以Jenkins要下2.357之前的，不然运行时会报jdk版本的错。
**此教程使用的是运行war包，**​下载地址 ☺️ 我的jenkins版本：2.332.3
上传到服务器后，在存放路径下运行命令

nohup java -jar jenkins.war --httpPort=9999 > jenkins.log 2>&1 &

通过httpPort来修改端口号，然后同级目录生成jenkins.log日志文件。

访问路径：IP:9999

  1. 稍微等一会出现jenkins等待页面
  2. 查看密码:
cat /root/.jenkins/secrets/initialAdminPassword

  1. 安装推荐的插件
  2. 创建用户
  3. 通过创建的账号和密码登录

    安装完成，搭配Gitee实现自动化部署项目还需安装两个插件
    插件安装步骤：
    Dashboard => Manager Jenkins => Manage Plugins
  • Maven Integration
  • Gitee

二、全局工具配置jdk、maven、git

Dashboard => Manager Jenkins => Global Tool Configuration
==Maven==

/usr/local/apache-maven-3.6.3/conf/settings.xml

/usr/local/apache-maven-3.6.3


==Java==

/usr/local/jdk1.8.0_361


==Git==

因为用的yum安装默认地址为：
/usr/libexec/git-core/git

三、配置Gitee




获取Gitee API令牌

  1. 登录gitee之后，访问如下网址：https://gitee.com/profile/personal_access_tokens,​然后生成新的令牌：
  2. 获取后填入即可
  3. 测试

    到这步，离成功不远了！！！坚持坚持

四、新建任务-部署Springboot项目








接下来，我们在这三个选项中填入对应的shell命令，选择调用shell

Pre Steps 构建之前

echo "停止demo服务"
pid=`ps -ef | grep 替换为你的jar包名称 | grep -v grep | awk '{print $2}'`
if [ -n "$pid" ]
then
   kill -9 $pid
fi
echo "停止demo服务成功"

Build

clean package -Dmaven.test.skip=true

Post Steps jenkins克隆下来的代码在/root/.jenkins/workspace下

BUILD_ID=DONTKILLME
echo "自定义创建放置jar包的目录"
if [ ! -d "/opt" ];then
  mkdir /opt/jar
  else
  echo "文件夹已经存在"
fi
if [ ! -f "/opt/jar/demo-0.0.1-SNAPSHOT.jar" ];then
  echo "文件不存在"
  else
  rm -f /opt/jar/demo-0.0.1-SNAPSHOT.jar
fi
mv -f /root/.jenkins/workspace/demo/target/demo-0.0.1-SNAPSHOT.jar /opt/jar/demo-0.0.1-SNAPSHOT.jar
echo "移动jar包完成"
echo "启动demo服务"
nohup java -jar /opt/jar/demo-0.0.1-SNAPSHOT.jar > /opt/jar/demo.log 2>&1 &
echo "启动demo服务完成"


在/opt/jar/demo.log中可以查看日志。至此jar包就启动完成啦。

1、安装依赖和相关库：

yum -y install gcc-c++ zlib-devel openssl-devel libtool

2、下载nginx安装包并解压：

cd /usr/local
wget http://nginx.org/download/nginx-1.14.0.tar.gz
tar -zxvf nginx-1.14.0.tar.gz

3、配置和安装

cd nginx-1.14.0
./configure --prefix=/usr/local/nginx --with-http_stub_status_module --with-http_ssl_module
make && make install

vue dist nginx配置：(在/usr/local/nginx/conf/的nginx.conf里面)

location / {
            root /home/server/dist;
            index index.html index.htm;
            try_files $uri $uri/ /index.html;
        }
##后台
location /api{
  proxy_pass http://服务器IP:后台端口号/;
}

4、启动nginx： (在/usr/local/nginx/sbin/里面)

cd ../nginx/sbin
./nginx

5、查看nginx:

ps -ef | grep nginx

结果如下所示

root 13850 1 0 17:01 ? 00:00:00 nginx: master process ./nginx

nobody 13851 13850 0 17:01 ? 00:00:00 nginx: worker process

root 13879 1128 0 17:11 pts/0 00:00:00 grep --color=auto nginx

6、停止和重启nginx： (在/usr/local/nginx/sbin/里面)

./nginx -s reload   #重启
./nginx -s stop #关闭

docker报错时查看日志命令

journalctl -xe
# 把错误拿去百度即可
# 经验一：是否是防火墙和docker内的网络冲突了，关掉防火墙试试！
systemctl stop firewalld.service    		--停止firewall
systemctl disable firewalld.service		--禁止firewall开机启动

一、Centos系统

1. 卸载旧版本依赖

sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine

2. 设置仓库

安装所需的软件包。yum-utils 提供了 yum-config-manager ，并且 device mapper 存储驱动程序需要 device-mapper-persistent-data 和 lvm2。

sudo yum install -y yum-utils \
  device-mapper-persistent-data \
  lvm2

使用以下命令来设置稳定的仓库。阿里云仓库

sudo yum-config-manager \
    --add-repo \
    http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

3. 安装最新版本的 Docker Engine-Community 和 containerd

sudo yum install docker-ce docker-ce-cli containerd.io

4.启动 Docker

systemctl start docker
# 重启 Docker
systemctl restart docker
# 停止 Docker
systemctl stop docker

5. 验证是否安装成功

docker version

出现如下图所示结果表示安装成功

Docker 需要用户具有 sudo 权限，为了避免每次命令都输入sudo，可以把用户加入 Docker 用户组。

sudo usermod -aG docker $USER

6.开机自启

systemctl enable docker

7.阿里云镜像加速

sudo mkdir -p /etc/docker
cat >> ~/.bash_profile << EOF
export SMOM_BASE=/opt/smom
EOF
source ~/.bash_profile
echo $SMOM_BASE #查看是否设置成功
sudo sh -c "cat > /etc/docker/daemon.json" << EOF
{
    "registry-mirrors": ["https://3n4m4jry.mirror.aliyuncs.com"],
    
"log-driver":"json-file",
     "log-opts": {
  
         "max-size":"50m",
     
         "max-file":"5"
      },
      
"graph":"$SMOM_BASE/docker"
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

卸载docker

sudo yum remove docker-ce docker-ce-cli containerd.io
sudo rm -rf /var/lib/docker

二、Ubuntu系统

sudo apt update
sudo apt-get install ca-certificates curl gnupg lsb-release
curl -fsSL http://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] http://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable"
sudo apt-get install docker-ce docker-ce-cli containerd.io
# docker命令免sudo
sudo gpasswd -a 用户名 docker
newgrp docker
# 开机自启
systemctl enable docker
# 阿里云镜像加速
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://3n4m4jry.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker
# 重启一下系统
reboot

一、JDK8

**链接：**​https://pan.baidu.com/s/1NfzIezipNTuAujzxcjTZ3w?pwd=pul3
提取码：pul3
–来自百度网盘超级会员V5的分享
解压：

tar -zxvf jdk-8u291-linux-x64.tar.gz

移动：

mv jdk1.8.0_291 /usr/local/jdk1.8

修改配置文件：

# Ubuntu
gedit /etc/profile
# Centos
vim /etc/profile

添加配置：

export JAVA_HOME=/usr/local/jdk1.8
export CLASSPATH=$:CLASSPATH:$JAVA_HOME/lib/
export PATH=$PATH:$JAVA_HOME/bin

刷新配置：

source /etc/profile

查看是否安装成功
运行命令

java -version

出现如下图所示即表示安装成功

二、JDK17

wget http://49.232.8.65/jdk/jdk17/jdk-17_linux-x64_bin.tar.gz
tar -zxvf jdk-17_linux-x64_bin.tar.gz
vim /etc/profile
# 文件添加如下内容
export JAVA_HOME=jdk文件夹全路径
export PATH=$JAVA_HOME/bin:$PATH
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
# 刷新配置使其生效
source /etc/profile
# 查看安装的版本
java -version

① 官方下载：

② 附件

也可以用下面的这个安装包，这个是3.9.6的

apache-maven-3.9.6-bin.tar.gz
下载好安装包之后，通过sftp工具丢到服务器喜欢的目录

# 查看存放路径
pwd

1、解压

# 解压
tar -zxvf apache-maven-3.9.6-bin.tar.gz

2、解压的文件移动到/usr/local/

本人应用程序习惯统一放在/usr/local/下，便于统一管理

mv apache-maven-3.9.6 /usr/local/

3、配置环境变量

# 修改 /etc/profile 系统文件
# Centos
vim /etc/profile
# Ubuntu
gedit /etc/profile
# maven环境配置
export MAVEN_HOME=/usr/local/apache-maven-3.9.6
export PATH=$PATH:$MAVEN_HOME/bin

保存后刷新，使文件生效

source /etc/profile

4、配置maven仓库地址

在maven安装目录下创建repository文件夹 例：/usr/local/apache-maven-3.9.6下

cd /usr/local/apache-maven-3.9.6
mkdir repository

修改 apache-maven-3.9.6/conf/settings.xml 文件：

# Ubuntu
gedit conf/settings.xml
# Centos
vim conf/settings.xml
<!-- 设置自定义仓库地址 -->
<localRepository>/usr/local/apache-maven-3.9.6/repository</localRepository>

<!-- 设置阿里云镜像 -->
<mirror>
  <id>alimaven</id>
  <name>aliyun maven</name>
  <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
  <mirrorOf>central</mirrorOf>
</mirror>

mvn -v

出现如下图所示即表示安装成功

查看主机当前内存

**free -h**

查看主机当前外存

**df -h**

查看当前主机运行的程序

**top**

删除文件/文件夹

rm 文件名 #删除文件
rm -d 目录名 #删除一个空目录
rm -r 目录名 #删除一个非空目录

安装Ubuntu终端分屏工具

**sudo apt install terminator**

shell脚本如下：（主要改的地方：第 2​ 、4、5、7、9、11、​13****​ 、14、16 行）

#用户名
mysql_user="root"
#密码
mysql_password="G#t9WhZr2@qL7BmPnXeD"
mysql_host="106.53.67.124"
#端口号 
mysql_port="3306"
#将要备份的数据库
database_name="test"
#编码格式
mysql_charset="utf8mb4"
#docker中MySQL容器的别名
docker_mysql_name="mysql"
#保存备份文件最多个数
count=1
#备份保存路径
backup_path=/data/mysql/bakup
#日期
date_time=`date +%Y-%m-%d-%H-%M`
#如果文件夹不存在则创建
if [ ! -d $backup_path ]; 
then     
    mkdir -p $backup_path; 
fi
#查看MySQL是否在运行
mysql_ps=`ps -ef |grep mysql |wc -l` 
echo "查看MySQL是否在运行：$mysql_ps" >> $backup_path/dump.log
mysql_listen=`netstat -an |grep LISTEN |grep $mysql_port|wc -l`
if [ [$mysql_ps == 0] -o [$mysql_listen == 0] ]; then
        echo "ERROR:MySQL is not running! backup stop!" >> $backup_path/dump.log
        exit
else
        echo "Welcome to use MySQL backup tools!" >> $backup_path/dump.log
echo "MySQL connect ok! Please wait......" >> $backup_path/dump.log
fi
#开始备份
echo "开始备份..." >> $backup_path/dump.log
docker exec $docker_mysql_name /usr/bin/mysqldump -h$mysql_host -P$mysql_port -u$mysql_user -p$mysql_password $database_name --default-character-set=$mysql_charset > $backup_path/$database_name-$date_time.sql
#开始压缩
cd $backup_path
tar -zcvf $database_name-$date_time.tar.gz $database_name-$date_time.sql
#更新备份日志
echo "压缩原文件 create $backup_path/$database_name-$date_time.tar.gz" >> $backup_path/dump.log
#删除源文件
rm -rf $backup_path/$database_name-$date_time.sql
echo "压缩后删除原文件 delete $backup_path/$database_name-$date_time.sql" >> $backup_path/dump.log
#找出需要删除的备份
delfile=`ls -l -crt  $backup_path/*.tar.gz | awk '{print $9 }' | head -1`
#判断现在的备份数量是否大于阈值
number=`ls -l -crt  $backup_path/*.tar.gz | awk '{print $9 }' | wc -l`
if [ $number -gt $count ]
then
  #删除最早生成的备份，只保留count数量的备份
  rm $delfile
  #更新删除文件日志
  echo "$date 删除 $count 前的文件 delete $delfile" >> $backup_path/dump.log
fi

开启定时服务

crontab -e
# 在出来的编辑界面加入以下内容，然后保存退出即可
# 每 5 分钟执行一次
*/5 * * * *  sh /data/mysql/dump_mysql.sh
# 每天凌晨 5 点执行
0 5 * * * sh /data/mysql/dump_mysql.sh

没有任何错误提示，则表示开启成功！出问题请参考​**((20251130181901-4tsgfo5 ‘MySQL数据库定时备份’))**

一、查看 MySQL 是否安装了 crontab

yum -y install vixie-cron
yum -y install crontabs

二、crontab 常用命令

# 查看进程是否正在进行
ps aux | grep crond
# 查看运行状态
systemctl status crond   或者 service crond status
# 启动服务
systemctl start crond  或者 service crond status
# 关闭服务
systemctl stop crond  或者 service crond status
# 重启服务
systemctl restart crond  或者 service crond restart
# 重新载入配置
systemctl reload crond
# 加入开机启动
systemctl enable crond
# 查看定时任务
crontab -l
# 编辑
crontab -e

三、编写 dump_mysql.sh 脚本

方式一：简单版

# 设置mysql的登录用户名和密码(根据实际情况填写)
mysql_user="root"
mysql_password="123456"
mysql_host="101.133.170.222"
mysql_port="3306"
mysql_charset="utf8"
# 备份文件存放地址(根据实际情况填写)
backup_location=/data/mysql/bakup
 
# 是否删除过期数据
expire_backup_delete="ON"
expire_days=7
backup_time=`date +%Y%m%d%H%M`
backup_dir=$backup_location
welcome_msg="Welcome to use MySQL backup tools!"
# 备份指定数据库中数据(此处假设数据库是ruoyi )mysql容器里面找到mysqldump我的路径是/usr/bin/mysqldump
docker exec mysql /usr/bin/mysqldump -h$mysql_host -P$mysql_port -u$mysql_user -p$mysql_password -B ruoyi > $backup_dir/mysql-$backup_time.sql
# 删除过期数据
if [ "$expire_backup_delete" == "ON" -a  "$backup_location" != "" ];then
        `find $backup_location/ -type f -mtime +$expire_days | xargs rm -rf`
        echo "Expired backup data delete complete!"
fi

方式二：复杂版

mysql_user="root"  #MySQL备份用户
mysql_password="123456" #MySQL备份用户的密码
mysql_host="101.133.170.222"
mysql_port="3306"  
mysql_charset="utf8" #MySQL编码0 2 * * * docker exec -i mysql sh /root/mysql8.0.20/mysqlbfplus/run.sh
backup_db_arr=("ruoyi") #要备份的数据库名称，多个用空格分开隔开 如("db1" "db2" "db3")
backup_location=/data/mysql/bakup  #备份数据存放位置，末尾请不要带"/",此项可以保持默认，程序会自动创建文件夹
expire_backup_delete="ON" #是否开启过期备份删除 ON为开启 OFF为关闭
expire_days=7 #过期时间天数 默认为三天，此项只有在expire_backup_delete开启时有效
backup_time=`date +%Y%m%d%H%M`  #定义备份详细时间
backup_Ymd=`date +%Y-%m-%d` #定义备份目录中的年月日时间
#backup_day_ago=`date -d 'expire_days days ago' +%Y-%m-%d` #备份之前的日期
backup_dir=$backup_location/$backup_Ymd  #备份文件夹全路径
welcome_msg="Welcome to use MySQL backup tools!" #欢迎语
mysql_ps=`ps -ef |grep mysql |wc -l` 
mysql_listen=`netstat -an |grep LISTEN |grep $mysql_port|wc -l`
if [ [$mysql_ps == 0] -o [$mysql_listen == 0] ]; then
        echo "ERROR:MySQL is not running! backup stop!"
        exit
else
        echo $welcome_msg

echo "MySQL connect ok! Please wait......"
fi
# 判断有没有定义备份的数据库，如果有定义则开始备份，否则退出备份
if [ "$backup_db_arr" != "" ];then
        #dbnames=$(cut -d ',' -f1-5 $backup_database)
        #echo "arr is (${backup_db_arr[@]})"
        for dbname in ${backup_db_arr[@]}
        do
                echo "database $dbname backup start..."
                `mkdir -p $backup_dir`
                docker exec mysql /usr/bin/mysqldump -h$mysql_host -P$mysql_port -u$mysql_user -p$mysql_password $dbname --default-character-set=$mysql_charset | gzip > $backup_dir/$dbname-$backup_time.sql.gz
                 flag=`echo $?`
                 if [ $flag == "0" ];then
                         echo "database $dbname success backup to $backup_dir/$dbname-$backup_time.sql.gz"
                 else
                         echo "database $dbname backup fail!"
                 fi
         done
else
        echo "ERROR:No database to backup! backup stop"
        exit
fi
# 如果开启了删除过期备份，则进行删除操作
if [ "$expire_backup_delete" == "ON" -a  "$backup_location" != "" ];then
         #`find $backup_location/ -type d -o -type f -ctime +$expire_days -exec rm -rf {} \;`
         `find $backup_location/ -type d -mtime +$expire_days | xargs rm -rf`
         echo "Expired backup data delete complete!"
fi

方式三：docker定时备份，根据备份数量删除

#用户名
mysql_user="root"
#密码
mysql_password="shijinying123"
mysql_host="101.133.170.222"
#端口号 
mysql_port="3306"
#将要备份的数据库
database_name="ruoyi"
#编码格式
mysql_charset="utf8"

#保存备份文件最多个数
count=3
#备份保存路径
backup_path=/data/mysql/bakup
#日期
date_time=`date +%Y-%m-%d-%H-%M`

#如果文件夹不存在则创建
if [ ! -d $backup_path ]; 
then     
    mkdir -p $backup_path; 
fi
#查看MySQL是否在运行
mysql_ps=`ps -ef |grep mysql |wc -l` 
echo "查看MySQL是否在运行：$mysql_ps" >> $backup_path/dump.log
mysql_listen=`netstat -an |grep LISTEN |grep $mysql_port|wc -l`
if [ [$mysql_ps == 0] -o [$mysql_listen == 0] ]; then
        echo "ERROR:MySQL is not running! backup stop!" >> $backup_path/dump.log
        exit
else
        echo "Welcome to use MySQL backup tools!" >> $backup_path/dump.log

echo "MySQL connect ok! Please wait......" >> $backup_path/dump.log
fi
#开始备份
echo "开始备份..." >> $backup_path/dump.log
docker exec h3_mysql /usr/bin/mysqldump -h$mysql_host -P$mysql_port -u$mysql_user -p$mysql_password $database_name --default-character-set=$mysql_charset > $backup_path/$database_name-$date_time.sql


#开始压缩
cd $backup_path
tar -zcvf $database_name-$date_time.tar.gz $database_name-$date_time.sql
#更新备份日志
echo "压缩原文件 create $backup_path/$database_name-$date_time.tar.gz" >> $backup_path/dump.log

#删除源文件
rm -rf $backup_path/$database_name-$date_time.sql

echo "压缩后删除原文件 delete $backup_path/$database_name-$date_time.sql" >> $backup_path/dump.log

#找出需要删除的备份
delfile=`ls -l -crt  $backup_path/*.tar.gz | awk '{print $9 }' | head -1`

#判断现在的备份数量是否大于阈值
number=`ls -l -crt  $backup_path/*.tar.gz | awk '{print $9 }' | wc -l`

if [ $number -gt $count ]
then
  #删除最早生成的备份，只保留count数量的备份
  rm $delfile
  #更新删除文件日志
  echo "$date 删除 $count 前的文件 delete $delfile" >> $backup_path/dump.log
fi

方式四：不是 docker 安装备份

#用户名
mysql_user="root"
#密码
mysql_password="root"
mysql_host="101.133.170.222"
#端口号 
mysql_port="3306"
#将要备份的数据库
database_name="ruoyi"
#编码格式
mysql_charset="utf8"

#保存备份文件最多个数
count=3
#备份保存路径
backup_path=/data/mysql/bakup
#日期
date_time=`date +%Y-%m-%d-%H-%M`

#如果文件夹不存在则创建
if [ ! -d $backup_path ]; 
then     
    mkdir -p $backup_path; 
fi
#查看MySQL是否在运行
mysql_ps=`ps -ef |grep mysql |wc -l` 
echo "$date_time 查看MySQL是否在运行：$mysql_ps" >> $backup_path/dump.log
mysql_listen=`netstat -an |grep LISTEN |grep $mysql_port|wc -l`
if [ [$mysql_ps == 0] -o [$mysql_listen == 0] ]; then
        echo "$date_time ERROR:MySQL is not running! backup stop!" >> $backup_path/dump.log
        exit
else
        echo "$date_time Welcome to use MySQL backup tools!" >> $backup_path/dump.log

echo "$date_time MySQL connect ok! Please wait......" >> $backup_path/dump.log
fi
#开始备份
echo "$date_time 开始备份...$backup_path" >> $backup_path/dump.log
docker exec h3_mysql /usr/bin/mysqldump -h$mysql_host -P$mysql_port -u$mysql_user -p$mysql_password $database_name --default-character-set=$mysql_charset > $backup_path/$database_name-$date_time.sql
echo "$date_time 备份完成...$backup_path" >> $backup_path/dump.log

#开始压缩
cd $backup_path
tar -zcvf $database_name-$date_time.tar.gz $database_name-$date_time.sql
#更新备份日志
echo  "$date_time 压缩原文件 create $backup_path/$database_name-$date_time.tar.gz" >> $backup_path/dump.log

#删除源文件
rm -rf $backup_path/$database_name-$date_time.sql

echo "$date_time 压缩后删除原文件 delete $backup_path/$database_name-$date_time.sql" >> $backup_path/dump.log

#找出需要删除的备份
delfile=`ls -l -crt  $backup_path/*.tar.gz | awk '{print $9 }' | head -1`

#判断现在的备份数量是否大于阈值
number=`ls -l -crt  $backup_path/*.tar.gz | awk '{print $9 }' | wc -l`

if [ $number -gt $count ]
then
  #删除最早生成的备份，只保留count数量的备份
  rm $delfile
  #更新删除文件日志
  echo "$date_time 删除 $count 前的文件 delete $delfile" >> $backup_path/dump.log
  echo "$date_time 备份成功" >> $backup_path/dump.log
fi

四、配置定时任务

时间格式：

# 常用时间格式
每五分钟执行 */5 * * * *
每小时执行 0 * * * *
每天执行 0 0 * * *
每周执行 0 0 * * 0
每月执行 0 0 1 * *
每年执行 0 0 1 1 *
# crontab 文件的格式
{minute} {hour} {day-of-month} {month} {day-of-week} {full-path-to-shell-script} 
 minute: 区间为 0 – 59 
 hour: 区间为0 – 23 
 day-of-month: 区间为0 – 31 
 month: 区间为1 – 12. 1 是1月. 12是12月. 
 Day-of-week: 区间为0 – 7. 周日可以是0或7.

常用时间：

# 执行 crontab -e 命令，写入以下命令保存，每 5 分钟执行一次
*/5 * * * *  sh /data/mysql/dump_mysql.sh
# 每天凌晨 5 点执行
0 5 * * * sh /data/mysql/dump_mysql.sh

保存如果出现问题

进入 **==/var/spool==**下查看cron目录是正常的，但是在cron里面没有权限建立文件这个根源。

（1）可以尝试先在 **==/var/spool/cron==**目录下用vim编辑一个测试文件，看是否可以保存在这个cron目录下，如果无法保存提示权限问题。那么可能目录有什么特殊的地方，root用户也被约束了

# 查看是否有特殊的属性
[root@izuf61151k3ad2dso6mo9oz cron]# lsattr /var/spool/cron/root
# 去掉特殊的属性
[root@izuf61151k3ad2dso6mo9oz cron]# chattr -ai /var/spool/cron/root
# 再次编辑定时任务
[root@izuf61151k3ad2dso6mo9oz cron]# crontab -e

执行 ==lsattr /var/spool/cron/root== 我们可以看到和常规的权限设置不一样，所以清楚这些特殊的属性

清除属性我们可以看到正常的权限的问题

再次执行 ==crontab -e== ，编辑模式，添加 ==*/5 * * * * sh /data/mysql/dump_mysql.sh==，保存即可

补充说明
crontab 时间格式说明

0 5 * * * /root/bin/backup.sh

获取讯飞星火三个参数方法

Web模式下，需要前往讯飞星火大模型web端通过 F12 抓取 3 个参数：cookie、fd、GtToken，讯飞星火的web端有防护，在web端直接按 F12 不能打开开发者窗口。但是可以通过特殊方法打开：

1.进入 https://xinghuo.xfyun.cn/

2.进入 F12 开发者窗口后，将网页修改为“手机端”窗口

3.在第二步完成后，才点击“进入体验”，进入讯飞星火的web端，可以发现成功变成手机端

4.先发一条简单的语句，让讯飞回复一段话，然后在“Network”栏目找到 “chat” 请求，在该请求下抓取 3 个参数


5.获取后，即可开始使用 Web 模式

一、SpringBoot项目

1、去你自己的云申请并下载好相关文件，SpringBoot下载的是Tomcat（默认），Vue2下载的是Nginx

2、将下载的压缩包里面的.pfx后缀文件拷贝到项目的resources目录下

3、编辑配置文件

（​主要是框里面的内容，注意是配置在server下****​ ）

二、Vue2项目

进入到你的nginx安装目录下面，我的目录是在（/usr/local/nginx），进入到目录的sbin目录下，输入

cd /usr/local/nginx/sbin
# 注意这里是大写的V，小写的只显示版本号
./nginx -V

如果出现 (configure arguments: --with-http_ssl_module)， 则已安装。

一般情况下都是不存在ssl模块的
接下来进入到你的解压缩后的nginx目录，注意这里不是nginx安装目录，是解压缩后的目录，我的是在（/usr/local/nginx-1.14.0），进入目录后，输入

./configure --prefix=/usr/local/nginx --with-http_stub_status_module --with-http_ssl_module

接下来执行make,切记不要执行make install，否则会重新安装nginx

make

上述操作执行完成以后，你的目录下会出现objs文件夹，文件夹内存在nginx文件，如图：

1 、接下来使用新的nginx文件替换掉之前安装目录sbin下的nginx，注意这里替换的之前可以先将之前的文件备份下，停掉nginx服务

一定要保证没有nginx进程在运行，先用命令查看是否还有nginx进程在运行,下图则表明还有nginx进程在运行

ps -ef | grep nginx


然后执行 ./nginx -s stop
如果还是跟上图一样，无法关闭，可以使用杀死进程方式关闭：（很重要这一步，一定要确保之前的进程都杀掉再往下走，不然怎么配置都没意义！！！）

ps -ef | grep nginx
kill -9 进程id
# 真杀不掉，那就用下面这个指令
pkill -9 nginx

上面没问题之后，往下走

#替换之前的nginx
cp /usr/local/nginx-1.14.0/objs/nginx /usr/local/nginx/sbin

成功之后，进入到nginx安装目录下，查看ssl是否成功

#注意这里是大写的V，小写的只显示版本号
./nginx -V
    
#可以看到这里出现了configure arguments: --with-http_ssl_module   证明已经安装成功

2、配置ssl证书

将下载的证书解压上传至服务器，（只需pem文件和key文件），我将它放在nginx安装目录下，创建cert文件夹

mkdir cert

3、修改nginx.conf配置文件（直接Ctrl+A，再CV全部覆盖掉nginx.conf里面的内容即可）

（主要改里面的第23、45、48、49、58行）

#user  nobody;
worker_processes  1;
#error_log  logs/error.log;
#error_log  logs/error.log  notice;
#error_log  logs/error.log  info;
#pid        logs/nginx.pid;
events {
    worker_connections  1024;
}
http {
    include       mime.types;
    default_type  application/octet-stream;
    server {
        # 监听端口80
        listen 80;
        # 配置域名 ---改---
        server_name www.keysqiu.online;
        # 重定向到HTTPS协议
        rewrite ^(.*)$ https://$host$1 permanent;
    }
    #log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
    #                  '$status $body_bytes_sent "$http_referer" '
    #                  '"$http_user_agent" "$http_x_forwarded_for"';
    #access_log  logs/access.log  main;
    sendfile        on;
    #tcp_nopush     on;
    #keepalive_timeout  0;
    keepalive_timeout  65;
    #gzip  on;
 server {
          listen       443 ssl;
          #你的域名，申请证书时填的是什么域名就填什么域名 ---改---
          server_name  keysqiu.online;
    
           #上传的证书 ---改---
          ssl_certificate      ../cert/keysqiu.online.pem;
          ssl_certificate_key  ../cert/keysqiu.online.key;
    
          ssl_session_cache    shared:SSL:1m;
          ssl_session_timeout  5m;
    
          ssl_ciphers  HIGH:!aNULL:!MD5;
          ssl_prefer_server_ciphers  on;
          #---改---
           location / {        
            	root /home/server/dist;
            	index index.html index.htm;
            	try_files $uri $uri/ /index.html;
            }
                
         error_page 404 /404.html;
           location = /404.html {
         }
        
         error_page 500 502 503 504 /50x.html;
           location = /50x.html {
         }
      }
}

4、重启nginx

./nginx -s reload

然后就可以通过https访问你的网站了，如果能够正常访问则说明配置成功，完结撒花，嘻嘻~~~

1 安装java (建议安装11版本的java)

sudo apt update
sudo apt install openjdk-11-jdk

安装完成后 查看下java版本是否安装完成

java -version

安装完成后输出下面的结果则表示成功

openjdk version “11.0.18” 2023-01-17

OpenJDK Runtime Environment (build 11.0.18+10-post-Ubuntu-0ubuntu120.04.1)

OpenJDK 64-Bit Server VM (build 11.0.18+10-post-Ubuntu-0ubuntu120.04.1, mixed mode, sharing)

2 安装jenkins

Ubuntu 上安装 Jenkins 相对比较直接。启用 Jenkins APT 软件源，导入源 GPGkey，并且安装 Jenkins 软件包。
用wget 获取软件源

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 update
sudo apt install jenkins

如果到此你安装成功了 那么恭喜你运气不错。。。
如果安装失败 报以下这种错

W: GPG error: https://pkg.jenkins.io/debian-stable binary/ Release: The following signatures couldn’t be verified because the public key is not available: NO_PUBKEY ******

E: The repository ‘https://pkg.jenkins.io/debian-stable binary/ Release’ is not signed.

N: Updating from such a repository can’t be done securely, and is therefore disabled by default.

N: See apt-secure(8) manpage for repository creation and user configuration details.

E: Package ‘jenkins’ has no installation candidate

那么其实很简单去官网看看是不是更新了源（搜了许多方案 都没解决 最终绕了一圈回到官网）
然后你就会发现 官网提供了稳定版的软件源 重新执行下以下命令 报错基本解决

curl -fsSL https://pkg.jenkins.io/debian-stable/jenkins.io-2023.key | sudo tee \
  /usr/share/keyrings/jenkins-keyring.asc > /dev/null
echo deb [signed-by=/usr/share/keyrings/jenkins-keyring.asc] \
  https://pkg.jenkins.io/debian-stable binary/ | sudo tee \
  /etc/apt/sources.list.d/jenkins.list > /dev/null
sudo apt-get update
sudo apt-get install jenkins

然后安装后的jenkins会被自动打开 可以使用 以下 命令查看是否安装成功

systemctl status jenkins

1、先在VMware Workstation里面扩展虚拟机的虚拟内存

2、安装gparted

sudo apt-get install gparted

2.1、打开gparted，开始重新调整磁盘大小（如果点击调整大小这里出现问题，请往后看，有解决方案）

2.2、填写好调整后的磁盘大小之后，点击应用全部操作即可


出现的问题：resize大小时候出现 cannot resize read-only file system

解决方案

① 右键需要被resize磁盘，点击“​信息****​ ”

② 记录该磁盘挂载文件夹目录，我这里系统挂载到两个位置，分别是 / 和 /var/snap/firefox/common/host-hunspell

③ 打开终端，进入root权限，重新挂载文件夹目录的读写权限，我这里系统挂载了两个目录，那么这两个目录都要重新挂载读写权限

sudo -i
mount -o remount -rw /
mount -o remount -rw /var/snap/firefox/common/host-hunspell

④ GParted中刷新设备

⑤ 再次进入调整大小，可以调整大小了

环境及工具

查看windows相关配置

打开任务管理器-> 选择性能 -> CPU ->虚拟化，确认是否已启用

一、开启 Hyper-v

在控制面板打开​程序​ ，然后点击启动或关闭windows功能

勾选点确定

如果进来没找到Hyper-v
桌面建一个​Hyper-V.bat​文件

pushd "%~dp0"
dir /b %SystemRoot%\servicing\Packages\*Hyper-V*.mum >hyper-v.txt
for /f %%i in ('findstr /i . hyper-v.txt 2^>nul') do dism /online /norestart /add-package:"%SystemRoot%\servicing\Packages\%%i"
del hyper-v.txt
Dism /online /enable-feature /featurename:Microsoft-Hyper-V-All /LimitAccess /ALL

把代码复制到Hyper-V.bat里面
然后右击用管理员身份员身份运行
配置完Hyper-V之后，重启一下电脑

一、开始安装

安装完wsl_update_X64.msi后，开始安装Docker Desktop


配置：
设置国内镜像地址：

"registry-mirrors": [
    "http://hub-mirror.c.163.com",
    "https://mirror.baidubce.com"
  ]

查看docker是否安装成功

常用命令：

# 查看docker安装
docker ps  或者  ps -ef | grep docker
 
# 查看docker服务：
systemctl status docker
 
# 设置开启docker服务:
systemctl enable docker
 
# 启动docker服务：
systemctl start docker
 
# 查看mysql镜像
docker search mysql
 
# 进入容器：
docker exec -it xxx bash

1、下载Redis压缩包

以下这个是我网盘里面的，后面小改一下路径即可

**链接：**​https://pan.baidu.com/s/18dT-0rMtZWQThhVrBtP88A?pwd=x0f1 提取码：x0f1
这里我在GitHub中下载window用的 5.0 版本Redis-x64-5.0.14.1.zip。

https://github.com/tporadowski/redis/releases

将下载的压缩包解压到指定的文件夹中，如：D:\Redis，内容如下：

3、启动Redis服务

在Redis的安装目录下打开cmd窗口，然后执行命令来启动服务：

redis-server.exe redis.windows.conf

默认端口为6379，出现图上的图标说明redis服务启动成功。命令里面的 redis.windows.conf 可以省略，省略后，使用redis-server.exe命令会使用默认的配置

为了方便，建议把Redis路径配置到系统变量Path值中，这样就省得再输路径了。

如果连接成功，到此Redis的安装和部署也就完成了。

Redis常用的服务指令

# 卸载服务
redis-server --service-uninstall 
# 开启服务
redis-server --service-start
# 停止服务
redis-server --service-stop

二、使用可视化工具

Redis Desktop Manager

需要安装使用，0.9.4以上是要收费的
**链接：**​https://pan.baidu.com/s/1wpqa3tViWm_2is0kWJfA4g?pwd=qwqp 提取码：qwqp
把安装包下载下来，改一下安装路径，然后不断下一步即可
无需任何配置直接连接-》

界面如下：

问题：

解决Linux服务器执行命令时出现 **==-bash: ./xxx.sh: /bin/sh^M: bad interpreter: No such file or directory==**报错

解决方案：

vim [脚本名称].sh
:set ff=unix
:wq

==镜像的概念：镜像是将应用程序及其需要的系统函数库、环境、配置、依赖打包而成。==

一 docker基本命令

镜像操作

① 查看所有镜像

docker images

② 搜索镜像（以jdk为例）

docker search jdk

③ 下载镜像

docker pull java

④ 启动镜像（以jdk8为例）

docker run -it --name jdk1.8 -d java:latest /bin/bash

⑤ 删除镜像

docker rmi [镜像id]
docker rmi [镜像名称]:[tag]

⑥ 数据卷直接挂载操作

语法：在docker run后面加上 -v参数

  • -v [宿主机目录]:[容器内目录]
  • -v [宿主机文件]:[容器内文件]

容器操作

① 进入某个容器进行操作

// 以进入mysql容器为例： 
docker exec -it {{容器名称/容器ID，用docker ps查看}} bash

② 查看所有运行着的容器

docker ps -a

③ 启动容器

docker start [容器id]

④ 停止容器

docker stop [容器id]

⑤ 删除容器

docker rm [容器id]

⑥ 查看运行的容器日志

docker logs [OPTIONS] 容器ID或容器名称
# 例：查看全部日志
docker logs -f 容器名称
 
[OPTIONS]
 
-f : 跟踪日志输出
 
-t : 显示时间戳
 
--tail :仅列出最新N条容器日志
 
--since：显示某个日期至今的所有日志

查看最近10条日志, 并持续打印

docker logs -f --tail 10 efb78392fcc6

0

查看某个日期至今的所有日志, 并持续打印

docker logs -f --since "2022-05-16" efb78392fcc6

二 安装mysql

docker login --username=akeys registry.cn-chengdu.aliyuncs.com
docker pull registry.cn-chengdu.aliyuncs.com/keys-docker-hub/mysql:8.1.0
# Ubuntu
sudo mkdir -p /tmp/mysql/data && sudo mkdir -p /tmp/mysql/conf && sudo gedit /tmp/mysql/conf/my.cnf
# Centos
sudo mkdir -p /tmp/mysql/data && sudo mkdir -p /tmp/mysql/conf && sudo vim /tmp/mysql/conf/my.cnf

mysql配置文件: vim /tmp/mysql/conf/my.cnf

[client]
default-character-set=utf8
[mysql]
default-character-set=utf8
[mysqld]
init_connect='SET collation_ connection = utf8mb4_unicode_ci'
init_connect='SET NAMES utf8'
character-set-server=utf8mb4
collation-server=utf8mb4_unicode_ci
skip-character-set-client-handshake
skip-name-resolve

主库配置

# mysql服务ID，保证整个集群环境中唯一，取值范围:1---2^32-1，默认为1
server-id=1
# 是否只读,1代表只读,0代表读写
read-only=0
# 忽略的数据,指不需要同步的数据库
#binlog-ignore-db=mysql
# 指定同步的数据库
#binlog-do-db=db01

从库配置

# mysql服务ID，保证整个集群环境中唯一，取值范围:1---2^32-1，默认为1
server-id=2
# 是否只读,1代表只读,0代表读写
read-only=1
# 忽略的数据,指不需要同步的数据库
#binlog-ignore-db=mysql
# 指定同步的数据库
#binlog-do-db=db01

启动mysql

# 第一个3306是物理机端口，第二个3306是docker容器端口
docker run --name mysql \
  -v /tmp/mysql/conf/my.cnf:/etc/mysql/my.cnf \
  -v /tmp/mysql/data:/var/lib/mysql \
  -e MYSQL_ROOT_PASSWORD=root \
  -p 3306:3306 \
  -d registry.cn-chengdu.aliyuncs.com/keys-docker-hub/mysql:8.1.0

然后修改权限

# 进入mysql容器：
docker exec -it mysql /bin/bash
# 登录mysql：
mysql -uroot -proot
# 修改密码：记得flush privileges一下
ALTER USER 'root'@'%' IDENTIFIED BY 'G#t9WhZr2@qL7BmPnXeD';
flush privileges;
# 修改了之后，如果exit退出去再重进还是没修改的话，不用理他，其实已经修改了的！用Navicat来连就知道了，意思就是拿Navicat来测

主库配置

CREATE USER 'itcast'@'%' IDENTIFIED WITH mysql_native_password BY 'Root@123456';

GRANT REPLICATION SLAVE ON *.* TO 'itcast'@'%';
# 查看binlog文件位置的命令
show master status;

从库配置

change replication source to SOURCE_HOST='主库IP',SOURCE_USER='主库设置的用户名',SOURCE_PASSWORD='主库设置的密码',SOURCE_LOG_FILE='主库log文件位置',SOURCE_LOG_POS=同步主库的开始位置;
# 例子：
change replication source to SOURCE_HOST='192.168.126.132',SOURCE_USER='itcast',SOURCE_PASSWORD='Root@123456',SOURCE_LOG_FILE='binlog.000002',SOURCE_LOG_POS=664;

# 开启同步操作
start replica;
# 查看主从同步状态
show replica status\G;

下图所示红框都是Yes说明主从复制开启成功！

0

测试是否已经部署成功

create database db01;
use db01;
create table tb_user(
id int(11)primary key not null auto_increment,
name varchar(50)not null,
sex varchar(1)
)engine=innodb default charset=utf8mb4;
insert into tb_user(id,name,sex)values(null,'Tom','1'),(null,'Keys','1'),(null,'HaHa','1');

主库中执行上述语句，看看从库有没有作相应改变，如果有，则完结撒花！！！

如果主库中已经存在数据了，可以先把主库中的数据导出到一个sql文件中，然后在从库中执行这个sql文件，再开启同步即可

三 安装Oracle

# 安装oracle
https://hub.docker.com/r/oracleinanutshell/oracle-xe-11g

docker pull oracleinanutshell/oracle-xe-11g

# 运行镜像  -p: 是容器内部端口绑定到指定的主机端口
docker run --name oracle -p 1521:1521 -e ORACLE_ALLOW_REMOTE=true oracleinanutshell/oracle-xe-11g

# 进入容器
docker exec -it oracle bash

# 连接 oracle
su oracle
cd $ORACLE_HOME
bin/sqlplus / as sysdba
# 创建账号
create user qingxi identified by 123456;
grant connect,resource to qingxi;

# 修改密码
alter user 用户名 identified by 新密码;

# 删除用户
drop user 用户名;

四 安装Postgresql

# 拉取镜像
docker pull postgres
# 启动镜像
docker run -d -p 5432:5432 -e POSTGRES_PASSWORD=pass123 postgres
# 进入容器
docker exec -it 容器id bash
# 连接pg
psql -U postgres -h 127.0.0.1 -p 5432

五 安装redis

docker pull redis

启动

// 创建配置文件
sudo mkdir -p /mydata/redis/data && sudo mkdir -p /mydata/redis/conf && sudo gedit /mydata/redis/conf/redis.conf
docker run -p 6379:6379 --name redis \
--restart=always \
-v /mydata/redis/data:/data \
-v /mydata/redis/conf/redis.conf:/etc/redis/redis.conf \
-d redis redis-server /etc/redis/redis.conf

redis-cli控制台:

docker exec -it redis redis-cli

redis开启持久化，修改配置文件redis.conf，启动aof持久化，输入：

appendonly yes

docker启动之后，mysql、redis也自动启动：

docker update mysql --restart=always
docker update redis --restart=always

六 安装portainer

-it表示使用交互方式运行容器，能进入容器内部进行内容的查看
-p 9000:9000把主机的9000端口映射到docker的9000端口上
--name给容器命名
--restart=always是重启策略，表示随着docker的重启而重启
-v表示把数据挂载到本机
--privileged=true表示授权
 
docker run -d -p 9000:9000  --name portainer \
--restart=always -v /var/run/docker.sock:/var/run/docker.sock \
--privileged=true portainer/portainer

七 Linux图形话监控netdata

docker run -d --name=netdata \
  -p 19999:19999 \
  -v netdataconfig:/etc/netdata \
  -v netdatalib:/var/lib/netdata \
  -v netdatacache:/var/cache/netdata \
  -v /etc/passwd:/host/etc/passwd:ro \
  -v /etc/group:/host/etc/group:ro \
  -v /proc:/host/proc:ro \
  -v /sys:/host/sys:ro \
  -v /etc/os-release:/host/etc/os-release:ro \
  --restart unless-stopped \
  --cap-add SYS_PTRACE \
  --security-opt apparmor=unconfined \
  netdata/netdata

八 安装Gitlab

docker run -d  -p 443:443 -p 8001:8001 -p 222:22 --name gitlab \
--restart always \
-v /home/gitlab/config:/etc/gitlab \
-v /home/gitlab/logs:/var/log/gitlab \
-v /home/gitlab/data:/var/opt/gitlab gitlab/gitlab-ce:12.7.6-ce.0
# -d：后台运行
# -p：将容器内部端口向外映射
# --name：命名容器名称
# -v：将容器内数据文件夹或者日志、配置等文件夹挂载到宿主机指定目录
   
# 配置http协议所使用的访问地址,不加端口号默认为80
external_url 'http://121.4.123.248'
# 配置ssh协议所使用的访问地址和端口
gitlab_rails['gitlab_ssh_host'] = '121.4.123.248'
# 此端口是run时22端口映射的222端口
gitlab_rails['gitlab_shell_ssh_port'] = 222 
nginx['listen_port'] = 8001
http://121.4.123.248:8001/
root/ChatP@ss7633

九 安装Grafana

docker pull grafana/grafana
docker run -d -p 3000:3000 --restart always --name=grafana \
-v /root/grafana/data:/var/lib/grafana grafana/grafana

十 安装 Prometheus

docker pull bitnami/prometheus
docker run \
-p 9090:9090 \
-v /root/prometheus/conf/prometheus.yml:/etc/prometheus/prometheus.yml \
--name prometheus bitnami/prometheus

作用：其实就相当于再生龙🐉，您细品

一、ocker就两步操作：
1、拉取(pull)镜像到本地
2、给镜像创建一个容器并run(跑)起来，其余的想要对哪个容器进行操作，就进入该容器中，执行的相关命令跟Ubuntu是差不多的
具体命令格式请参考​**((20251130181901-0z79ooh ‘docker安装各种组件’))**
二、docker默认是需要sudo权限的，看到什么权限报错，就在前面加上sudo
三、迭代自定义镜像时，每次都一定要记得commit当前镜像的环境才push到远程，不然不更新(呜呜呜~~~)
按我理解 简言之（​我愿称之为顶级理解****​ ）

docker 镜像： ----java中 class
docker 容器： ----java中 class new 出来的实例对象

docker compose
其实就是用一个docker-compose.yml文件来配置好 docker 镜像和容器的端口号、参数、网络，跟 SpringBoot的配置文件作用一样

前提：确保主控机和被控机处于同一局域网内

Windows安装

**链接：**​https://pan.baidu.com/s/1CwC8KfN93qLGKa0ecCjLNQ?pwd=tzt9
提取码：tzt9
–来自百度网盘超级会员V5的分享

Linux安装

**链接：**​https://pan.baidu.com/s/1VRlei2hdofWFZ7m_K5S-7A?pwd=ph0p
提取码：ph0p
–来自百度网盘超级会员V5的分享

sudo dpkg -i nomachine_8.11.3_4_amd64.deb

查看make版本：

**make -v**

查看cmake版本：

**cmake -version**

安装cmake命令：

**sudo apt-get install cmake**

查看opencv版本：

**pkg-config --modversion opencv**

1、前期准备

1.1 安装Xshell和Xftp

安装包.zip

ps:文件解压完之后双击安装即可，如若提示更新，点击立即更新，不然它不给使用，后面再注册一下即可使用

1.2 利用Xshell连接远程服务器

① 在弹出的界面中点击新建会话，按下图填写相应的信息即可

② 连接成功如下图所示

1.3 利用Xftp与远程服务器进行文件传输

2、后端项目打包好后（war包），直接放在/usr/local/tomcat/tomcat9/webapps目录下即可，不要怀疑，就这么简单！！！【如果是打成jar包的话，随便放一个目录，然后在终端输入以下命令即可】

# 给jar包执行的权限
chmod 777 [自己jar包名称].jar
# 启动（临时运行）
java -jar [自己jar包名称].jar
# 启动（在后台运行）
nohup java -jar [自己jar包名称].jar & (注意最后面还有一个&符号)

3、前端项目打包好后，直接放在/usr/local/nginx目录即可，不要怀疑，就这么简单！！！

先看！！！（ps：前提是你已经配置好nodejs，一般高版本的nodejs里面都内置有npm，所以需不需要安装npm可以看nodejs的版本）

1、安装nodejs教程网址
https://blog.csdn.net/m0_63550153/article/details/136531545
2、安装maven教程
2.1 从自己的网盘上把maven包拉下来，链接为：
https://pan.baidu.com/s/1xUQ-g4cXpfu6IMl88qxsMg?pwd=y718 
2.2 然后配置一下环境变量
环境变量里面配置如下：
    新建 变量名：MAVEN_HOME,路径：D:\Java\maven\apache-maven-3.9.5，视具体的路径来定，这只是告诉你copy到哪个路径
    Path里面：%MAVEN_HOME%\bin
2.3 最后修改一下maven包里面的配置文件，路径为..\maven\apache-maven-3.9.5\conf文件夹下的settings.xml文件，修改的地方是 55行，把localRepository标签里面的路径更改为实际的本地仓库路径即可

1、安装依赖

npm install  #如果npm下的死慢，请看下面这条命令
#建议不要直接使用 cnpm 安装依赖，会有各种诡异的 bug。可以通过如下操作解决 npm 下载速度慢的问题
npm install --registry=https://registry.npmmirror.com

2、安装完成 启动服务

npm run serve 或 npm run dev
浏览器访问 http://ip:port

# 启动时报error:0308010C:digital envelope routines::unsupported
set NODE_OPTIONS=--openssl-legacy-provider

1. SSH终端连接虚拟机

首先，肯定是先用root​账号登录一台即将安装Portainer的虚拟机。事实上，你完全可以直接选中虚拟机，然后点击连接进入系统，如下图所示：
image
但是这样做会有一些很明显的缺点，比如：

  • 每次登录都要重新输入账号密码；
  • 命令必须手动输入，无法与宿主机之间通过复制粘贴实现快速交互；
  • 上传文件比较麻烦，需要额外安装相关工具；
  • 无法通过滚动鼠标来查看历史操作日志等。

这些虽然不是什么致命的缺点，但却十分影响使用体验，而通过SSH客户端，就不会有这些问题。这里我们依然使用前面已经安装的electerm，有不清楚的可以看一下《比Xshell更好用更酷炫的免费开源SSH/SFTP终端工具》这篇文章。接下来我们看一下如何通过electerm连接虚拟机。

1.1 启动虚拟机

用SSH终端连接之前需要启动虚拟机，如下图所示：
image
这里选择启动而不是连接，因为启动只会后台运行，不会打开一个客户端窗口。

1.2 连接虚拟机

这里比较简单，直接上图，不清楚的可以看一下前面讲SSH/SFTP终端工具的那篇文章。
image
不同的是，这次不用私钥登录，而是直接使用root密码，另外，主机地址需要从如下图所示的位置获：
image
值得注意的是，由于这里的IP​是由DHCP​动态分配，所以并不是一成不变的，不过也不用太担心，DHCP​服务器默认的租期为8​天，也就是说，只要8​天内虚拟机有被使用，IP​就不会变，你也可以改成固定IP。当然，动态IP​也有动态IP​的好处，其中之一就是不用每次复制创建虚拟机都需要修改IP​。最后，别忘了取一个有意义的标题，然后保存并连接就可以了。

2. 安装Docker引擎

这一节直接参考《Docker环境部署》安装Docker和Docker Compose，并配置镜像加速器。值得注意的是，由于这里是通过root​用户安装的，所以不需要使用sudo命令，安装后的效果如下图所示：
image
下一步就可以安装Portainer了，不过在这之前，我建议赶紧先创建一个检查点，因为快速搭建一个干净的Docker环境太重要了，效果如下图所示：
image
我这里有两个检查点，并分别重命名了，其中，一个是干净的CentOS系统，另一个是干净的Docker环境，然后再重新导出备份一下系统。这样一来，备份文件里面就也有两个检查点了，后续如果有需要，直接导入虚拟机就能快速得到一个部署好Docker环境的虚拟机了，怎么样？方便吧？

3. 安装Portainer

关于Portainer的安装，我建议大家直接查阅官方文档：Install Portainer CE with Docker on Linux，你在网上其它地方搜到的资料大概率都是过时的，因为portainer/portainer这个仓库现在已被弃用了。我这里参考官方文档，然后结合我的情况简单介绍一下安装过程。

3.1 环境要求

安装Portainer之前，请确保你的环境满足以下要求：

  • 已安装并运行23.0.6及以上版本的Docker；
  • SELinux已被禁用，如果没有禁用，则需要在部署Portainer时指定--privileged参数；
  • Docker以root身份运行。

3.2 运行容器

执行如下脚本，即可部署并启动Portainer容器：

docker run -d -p 9443:9443 --name portainer --restart=always \
-v /var/run/docker.sock:/var/run/docker.sock \
-v /data/portainer:/data \
portainer/portainer-ce:latest

值得注意的是，官方文档中，运行容器之前先创建了一个portainer_data​卷，这个卷默认挂载在/var/lib/docker/volumes/​目录下，我这里为了方便维护，将目录挂载到了/data/portainer​目录下，可通过tree命令查看目录结构，如下图所示：
image
该目录不需要提前创建，容器部署时，会自动生成。另外，8000端口我这里用不上，所以也没有开放。

3.3 访问Portainer

访问https://<虚拟机IP>:9443​，即可进入Portainer创建用户的界面，如下图所示：
image

上面的域名、端口以及证书问题，也可以处理，但我这里不想搞那么麻烦，本来就是本地虚拟机，没有强迫症的话，就先将就这么用了。

填上密码，点击Create user，创建完成之后，会打开如下页面：
image
安装过程会自动检测本地环境并进行设置，点击Get Started开始使用，就能看到如下界面，自动就有了一个local环境：
image
如果要添加其他环境，则需要点击Add Environments，当然也可以随后再到Environments中添加。

4. 远程管理

如果只是管理本地环境，那么到这里就可以结束了，但如果仅此而已的话，那安装Portainer就没太大意义了。我们实际想要的是远程管理来自不同服务器上的多个Docker环境。基于这种需求，Portainer提供了多种方式，我这里不一一介绍，而是直接采用Docker API方式，这也是我最推荐的方式，具体可以参考官方文档：Connect to the Docker API。不过既然是远程管理，那么在这之前，肯定是需要让远程服务器的Docker进程允许远程访问的。

4.1 生成证书

这里主要参考官方文档：Use TLS (HTTPS) to protect the Docker daemon socket。操作均在服务器上的/root目录下进行（事实上，证书在哪里生成都可以），详细步骤如下：

  1. 生成CA私钥，这里会提示设置密码，两次输入需要相同。

    openssl genrsa -aes256 -out ca-key.pem 4096

  2. 生成CA公钥（注意：这里的有效期设置成了 365 天，也就是说该公钥并非永久有效，到期后需要重新生成。当然，如有必要，你也可以设置更长的过期时间）。

    openssl req -new -x509 -days 365 -key ca-key.pem -sha256 -out ca.pem

    这里需要输入刚才设置的密码，然后设置一些基本信息，可以随便填，也可以不填，但需要注意的是，Country Name应该填CN​，Common Name应该填服务器的外网IP，如下图所示：
    image

  3. 生成服务器端的私钥。

    openssl genrsa -out server-key.pem 4096

  4. 生成服务器端的证书签名请求，这里的IP需要替换成你自己的服务器IP。

    openssl req -subj "/CN=111.229.186.72" -sha256 -new -key server-key.pem -out server.csr

  5. 生成服务端配置文件extfile.cnf，注意替换IP。

    echo subjectAltName = IP:111.229.186.72,IP:0.0.0.0 >> extfile.cnf && echo extendedKeyUsage = serverAuth >> extfile.cnf

  6. 生成服务器端的证书，需要输入密码（有效期同上，不再赘述）。

    openssl x509 -req -days 365 -sha256 -in server.csr -CA ca.pem -CAkey ca-key.pem \
-CAcreateserial -out server-cert.pem -extfile extfile.cnf

  7. 生成客户端的私钥。

    openssl genrsa -out key.pem 4096

  8. 生成客户端的证书签名请求。

    openssl req -subj '/CN=client' -new -key key.pem -out client.csr

  9. 生成客户端的配置文件extfile-client.cnf。

    echo extendedKeyUsage = clientAuth > extfile-client.cnf

  10. 生成客户端的证书，需要输入密码（有效期同上，不再赘述）。

    openssl x509 -req -days 365 -sha256 -in client.csr -CA ca.pem -CAkey ca-key.pem \
-CAcreateserial -out cert.pem -extfile extfile-client.cnf

  11. 删除无用的文件。

    rm -fv client.csr server.csr extfile.cnf extfile-client.cnf

  12. 删除写入访问权限，以防止意外损坏。

    chmod -v 0400 ca-key.pem key.pem server-key.pem && \
chmod -v 0444 ca.pem server-cert.pem cert.pem

上述一系列操作，其实就是为了生成CA证书，服务端证书以及客户端证书相关的一系列文件，如下图所示：
image
这些证书生成不易，可以保留着，以备不时之需。

4.2 配置服务端证书

  1. 通过vim​修改/lib/systemd/system/docker.service​文件，使Docker守护进程仅接受来自提供CA信任的客户端的请求，如下图所示：
    image
    插入的内容如下：

    --tlsverify --tlscacert=~/ca.pem --tlscert=~/server-cert.pem --tlskey=~/server-key.pem -H tcp://0.0.0.0:2376

  2. 重新加载systemd配置并重启Docker服务。

    systemctl daemon-reload && systemctl restart docker

  3. 放通2376端口，如下图所示。
    image

4.3 配置客户端证书

首先，把上面生成的ca.pem​、cert.pem​、key.pem​三个文件复制到本地，然后在Portainer中添加环境，如下图所示：
image
环境类型选择Docker，然后如下图所示填写信息，最后点击Add environment就添加成功了。
image
可以看到，列表中多了一个腾讯云的Docker环境了。
image
点进去就能看到我们之前通过脚本创建的一些容器，这里我就不再继续展开了。

实现步骤

实现步骤

Ctrl+Alt+T，新建一个终端

# 卸载已有的工具
sudo apt-get autoremove open-vm-tools
# 安装工具open-vm-tools
sudo apt-get install open-vm-tools
# 安装open-vm-tools-desktop	
sudo apt-get install open-vm-tools-desktop
# 重启Ubuntu系统
reboot

前期工作

项目地址：
https://github.com/danni-cool/docker-wechatbot-webhook
简单来说就是docker封装的微信机器人，可以实现自动化收发消息，可以一键部署到Linux服务器。

1、首先在Ubuntu系统安装docker

sudo apt update
sudo apt-get install ca-certificates curl gnupg lsb-release
curl -fsSL http://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] http://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable"
sudo apt-get install docker-ce docker-ce-cli containerd.io

2、拉取镜像

sudo docker pull dannicool/docker-wechatbot-webhook

3、运行镜像， 注意修改自定义token

sudo docker run -d \
--name wxBotWebhook \
-p 3001:3001 \
-e LOGIN_API_TOKEN="techshrimp" \
dannicool/docker-wechatbot-webhook

访问以下地址，扫码即可登陆微信机器人，注意将localhost替换成linux机器的ip，token即上一步的自定义token。（端口号3001也可以进行修改）

具体使用

1、发送消息

在postman中发送post请求，如下图所示

上图中，192.168.126.128为你部署docker镜像的主机IP，3001为你启动微信机器人这个镜像时设置的端口号，to为接收方的昵称（注：不是你备注的，而是对方自己设置的昵称）其他的就不需要修改了，只是测试一下是否联通而已（注意：如果只有一个手机的话，切换账号之后，当前账号会在所有设备上登出，因为这个还找了一会问题，甚至看了源码，最好用微信分身【这样就不用切换账号了】，谁叫iPhone不支持，真的艹了）

2、接受信息

启动时需要多添加一行配置
**-e RECVD_MSG_API="**​http://localhost:8080/receive_msg​ "
即微信消息转发地址，微信机器人收到消息后都会转发到目标路径

sudo docker run -d \
--name wxBotWebhook \
-p 3001:3001 \
-e LOGIN_API_TOKEN="techshrimp" \
-e RECVD_MSG_API="http://localhost:8080/receive_msg" \     #增加了这一行配置
dannicool/docker-wechatbot-webhook

可以写一个python的web端来接收转发过来的消息，此处就简单打印了一下

# 先安装依赖
# pip3 install fastapi uvicorn python-multipart
from fastapi import FastAPI, Form
import uvicorn
app = FastAPI()
@app.post("/receive_msg")
async def print_json(type: str = Form(), content: str = Form()):
    print(content)
    return {"message": "Data received and printed"}
if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8080)

C/S架构

服务器：监听某个端口，等待客户端连接
客户端：利用已知的（主机IP、主机监听的端口号）与服务器建立socket连接
建立连接之后，后面的操作那不水到渠成了，嘿嘿嘿~~~

B/S架构

服务器：监听某个端口，等待客户端发起请求
客户端：利用已知的（主机IP、主机监听的端口号）对服务器发起请求

想要理解好这两段话，你可以这样想，C/S架构的软件，哪里有什么路由，也没地方给你输路由啊，所以它只能先连接再服务，断开连接不服务，而 B/S 架构不一样，它有路由，用户输入路由后，至于服务器服不服务，这得看你路由对不对，还有服务器开没开起来
总结一句话就是（这个思想几乎适用于所有软件开发）：
（C/S 架构强调连接，B/S 架构强调路由）

如果报-bash: ./xxx.sh: /bin/sh^M: bad interpreter: No such file or directory

请参考​**((20251130181901-k8zkr2m ‘bad interpreter,No such file or directory’))**

deploy_software.sh（安装软件）

#!/usr/bin/bash
echo -e "\n\n\n\n"
echo "脚本开始执行=======================================";
# 检测git
if !(command -v git >/dev/null)
then
    echo -e "\n\n\n\n"
    echo "系统没有安装git，开始安装git=================";
    yum install git -y
    echo "安装git结束=================================";
fi
# 检测java
if !(command -v java >/dev/null)
then
    echo -e "\n\n\n\n"
    echo "系统没有安装java，开始安装java================";
    yum install java -y
    echo "安装java结束=================================";
fi
# 检测expect
if !(command -v expect >/dev/null)
then
    echo -e "\n\n\n\n"
    echo "系统没有安装expect，开始安装expect================";
    yum install expect -y
    echo "安装expect结束=================================";
fi
# 检测docker
if !(command -v docker >/dev/null)
then
    echo -e "\n\n\n\n"
    echo "系统没有安装docker，开始安装docker================";
    # 添加docker 的yum源
    yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
    # 清除docker 的yum源缓存
    yum clean all
    # 重新加载docker 的yum源
    yum makecache
    #安装docker
    yum -y install-docker-ce
    #启动docker
    systemctl start docker
    #设置开机自动启动docker
    systemctl enable docker
    echo "安装docker结束=================================";
fi
echo -e "\n\n\n\n"
echo "脚本执行结束=======================================";

安装完以上的之后还要配置Git

参照​git安装​里面的1.3即可，需要注意的是，生成的ssh公钥在​ ==/root/.ssh/==​里面，用以下命令查看

cat /root/.ssh/id_rsa.pub

安装完以上的之后还要安装Maven

((20251130181901-c8urip8 ‘Linux安装maven指定版本’))

deploy_springboot.sh（部署服务）

#!/usr/bin/bash
#配置代码仓库用户名
git_username="13197630087"
#配置代码仓库密码
git_password="qqs20020906"
#项目名字
project_name="vue_springboot"
project_name_1="springboot"
#代码仓库路径，.git的那个链接
git_path="git@gitee.com:qiuqingsheng/vue_springboot.git"
#主机端口
esc_port="9090"
#Java服务端口，也是docker容器端口
docker_port="9090"
echo -e "\n\n\n\n"
echo "脚本开始执行=======================================";
echo "开始清除之前项目文件=======================================";
rm -rf $project_name
echo "清除之前项目文件结束=======================================";
echo -e "\n\n\n\n"
echo "开始克隆代码=======================================";
/usr/bin/expect <<EOF
#这里意味着bash脚本中嵌套着expect脚本
    set timeout -1
    spawn git clone ${git_path}
    expect {
        "Username*:"{send "$git_username\r";exp_continue}
        "Password*:"{send "$git_password"}    
    }
    expect eof
EOF
echo "克隆代码成功=======================================";
echo -e "\n\n\n\n"
echo "开始进入项目目录=======================================";
cd ${project_name}
echo "进入项目目录结束=======================================";
echo -e "\n\n\n\n"
echo "开始构建项目，打包jar=======================================";
mvn clean package -Dmaven.test.skip=true
echo "构建项目结束=======================================";
echo -e "\n\n\n\n"
echo "开始制作docker镜像=======================================";
docker build -t $project_name_1 ./
echo "制作docker镜像结束=======================================";
echo -e "\n\n\n\n"
echo -e "\n\n\n\n"
echo "开始部署服务=======================================";
#停止正在运行的docker容器
docker stop $project_name_1
#删除正在运行的docker容器
docker rm $project_name_1
#启动运行docker容器
docker run -d --name $project_name_1 -p $esc_port:$docker_port $project_name_1
echo "部署服务结束=======================================";
echo -e "\n\n\n\n"

跨域：域名不一致就是跨域，主要包括：