⛳ 本页显示常用笔记，更多笔记请访问 [笔记分类]

开发环境安装

nvm及node的安装

nvm（Node Version Manager）是一个流行的工具，用于在同一台机器上安装和管理多个版本的Node.js。以下是使用nvm安装Node.js的步骤：

安装nvm

对于MacOS和Linux用户：

打开终端（Terminal）并运行以下命令来下载nvm安装脚本：

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash

或者，如果你更喜欢使用wget，可以使用：

wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash

这些命令将下载并执行nvm的安装脚本。安装完成后，你需要重新启动终端或者运行以下命令来获取nvm的路径：

export NVM_DIR="$([ -z "${XDG_CONFIG_HOME-}" ] && printf %s "${HOME}/.nvm" || printf %s "${XDG_CONFIG_HOME}/nvm")"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh" # This loads nvm

对于Windows用户：
nvm在Windows上的版本叫做nvm-windows。你可以从GitHub上的nvm-windows项目页面或者Releases · coreybutler/nvm-windows (github.com)下载安装程序并按照指示进行安装。

安装Node.js

安装nvm后，你可以使用以下步骤来安装Node.js：

打开终端（对于MacOS和Linux）或命令提示符/PowerShell（对于Windows）。
使用nvm安装Node.js的最新版本，运行以下命令：
```
nvm install node # "node" 是指最新版本的Node.js
```
如果你想安装特定版本的Node.js，可以指定版本号，例如：
```
nvm install 14.17.0
```
安装完成后，你可以使用nvm use命令来切换到刚刚安装的Node.js版本：
```
nvm use node # 也可以使用 nvm use node
```
或者，如果你想设置默认Node.js版本，可以使用：
```
nvm alias default node
```
这样，每次打开新的终端会话时，都会自动使用你指定的默认版本。
验证Node.js是否安装成功，运行以下命令：
```
node -v
```
这将显示当前使用的Node.js版本。

通过以上步骤，你可以轻松地使用nvm在本地机器上安装和管理不同版本的Node.js。记得在安装或切换Node.js版本后，重新启动你的终端或命令行界面以确保nvm的更改生效。

手动安装Node.js

在Linux系统中，手动安装Node.js v20.x版本通常涉及以下步骤：

下载Node.js二进制文件：访问Node.js官方网站下载页面，选择v20.x版本的最新稳定版，然后下载对应Linux架构的二进制文件。
解压下载的文件：使用tar命令解压下载的Node.js二进制文件。
移动Node.js到系统路径：将解压后的Node.js文件移动到/usr/local/lib/nodejs或其他你选择的目录。
更新系统PATH：更新你的系统PATH环境变量，以便可以全局访问Node.js命令。
验证安装：运行node -v和npm -v来验证Node.js和npm是否安装成功。

注意：如果您的用户为root用户，执行下列命令时无需使用sudo

以下是具体的命令步骤：

下载Node.js v20：（默认下载到根目录）

curl -O https://nodejs.org/dist/v20.10.0/node-v20.10.0-linux-x64.tar.xz
# 或者使用国内阿里源下载
curl -O https://mirrors.aliyun.com/nodejs-release/v20.10.0/node-v20.10.0-linux-x64.tar.xz

请替换上面的URL为最新的v20.x版本对应的链接。

创建Node.js目录：

sudo mkdir -p /usr/local/lib/nodejs

解压Node.js：
如果没有安装xz的解压缩工具，请使用如下步骤进行安装xz-utils包用于解压Node.js
在基于Debian的系统（如Ubuntu）上，你可以通过以下命令安装xz-utils：
```
sudo apt update
sudo apt install xz-utils
```
在基于Red Hat的系统（如CentOS或Fedora）上，你可以使用以下命令安装：
```
sudo yum install xz
```
或者，如果你使用的是dnf包管理器：
```
sudo dnf install xz
```
安装了xz-utils之后，你应该能够使用tar命令正确解压.tar.xz文件。再次尝试解压Node.js的压缩包。
```
sudo tar -xJvf node-v20.10.0-linux-x64.tar.xz -C /usr/local/lib/nodejs
```
请确保解压到的目录存在于你的系统中。
更新PATH环境变量：你可以选择为所有用户更新PATH，或者只为当前用户更新。以下是为当前用户更新的示例：
```
export PATH=/usr/local/lib/nodejs/node-v20.10.0-linux-x64/bin:$PATH
```
如果你想要永久更改，可以将上面的export命令添加到你的~/.profile或~/.bashrc文件中。
验证安装：
```
node -v
npm -v
```
这将输出Node.js和npm的版本号，确认它们已正确安装。
全局安装npm包（如果需要）：如果需要全局安装某些npm包，可以使用：
```
npm install -g package-name
```

查看版本

1.查看本地已经安装的node版本

nvm list

2.查看所有可安装的版本列表

nvm list available

Docker

CentOS 7 x86_64安装Docker

在您的CentOS 7 x86_64系统上安装Docker的详细步骤：

如果您不知道自己的系统信息，可以使用uname -a命令查看。

卸载旧版本的Docker（如果已安装）：在安装新版本的Docker之前，如果您的系统上已经安装了旧版本的Docker，建议先卸载它以避免潜在的冲突。可以通过以下命令来卸载：
```
sudo yum remove docker docker-engine docker.io containerd runc
```

安装依赖包：在安装Docker之前，您需要确保系统已经安装了必要的依赖包。可以通过以下命令安装这些依赖：

# 1. 备份原有源配置
sudo mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup
# 2. 下载阿里云 Vault 源（国内推荐）
sudo curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
# 执行安装命令
sudo yum install -y yum-utils device-mapper-persistent-data lvm2

设置Docker的稳定版仓库：为了确保从官方仓库下载的软件包是最新的，您需要设置Docker的稳定版仓库。可以通过以下命令添加Docker的仓库：
```
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
```
如果设置失败，例如：报错Could not fetch/save xxxxxxx :[Errno 14] curl#35 - "TCP connection reset by peer"可尝试添加阿里云镜像仓库为Docker仓库，使用如下命令：
```
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo 
```
安装Docker引擎：现在，您可以安装Docker引擎了。通过以下命令安装Docker引擎：
```
sudo yum install docker-ce docker-ce-cli containerd.io
```
如遇依赖报错，可尝试运行：wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo，运行该命令后再次运行上述安装Docker引擎命令
启动Docker服务：安装完成后，您需要启动Docker服务，并将其设置为开机自启动：
```
sudo systemctl start docker
sudo systemctl enable docker
```
验证Docker安装：为了确认Docker已经成功安装并可以正常工作，您可以运行一个测试命令来验证：
```
sudo docker run hello-world
```
如果一切顺利，这个命令将会下载一个测试镜像并运行它。当容器运行时，它会打印一条消息并退出。如果看到了这个消息，那么恭喜您，Docker已经成功安装并准备好使用了。

请按照上述步骤操作，如果在安装过程中遇到任何问题，可以参考Docker的官方文档或者社区论坛来寻求帮助。祝您安装顺利！

Ubuntu系统安装Docker

更新系统包

打开终端，首先更新你的系统包：

sudo apt update -y

安装依赖

安装一些必要的包，比如 curl 和 apt-transport-https：

sudo apt install curl apt-transport-https -y

3.添加 Docker 阿里云镜像源

sudo curl -fsSL https://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

4.安装 Docker

更新 apt 源并安装 Docker：

sudo apt-get update

sudo apt-get install docker-ce docker-ce-cli containerd.io -y

docker拉取镜像文件

在Docker中，拉取镜像文件通常指的是从Docker Hub或其他Docker镜像仓库下载（或称为拉取）一个已经存在的镜像到你的本地Docker环境中。这个过程非常直接，并且可以通过一条简单的命令来完成。

以下是拉取Docker镜像的步骤和一些有用的信息：

1. 确定需要的镜像

首先，你需要知道你想要拉取的镜像的名称。这通常包括镜像的仓库名称和标签（tag）。标签用于指定你想要拉取的特定版本，比如 latest 通常是默认的标签，表示拉取最新版本的镜像。

2. 使用 `docker pull` 命令

接下来，你可以使用 docker pull 命令来拉取镜像。命令的基本格式如下：

docker pull [OPTIONS] NAME[:TAG]

[OPTIONS] 是可选的参数，比如 --platform 指定平台，--pull 强制拉取。
NAME 是镜像的名称。
:TAG 是镜像的标签，如果省略，默认为 latest。

例如，要拉取最新版本的Ubuntu镜像，你可以执行：

docker pull ubuntu:latest

如果你想拉取特定版本的镜像，比如18.04版本，你可以指定标签：

docker pull ubuntu:18.04

3. 验证镜像是否拉取成功

拉取完成后，你可以使用 docker images 命令来查看本地的镜像列表，确认新拉取的镜像是否在列表中。

docker images

4. 使用拉取的镜像

一旦镜像被拉取到本地，你就可以使用它来创建容器了。例如，使用以下命令来运行一个基于刚刚拉取的Ubuntu镜像的容器：

docker run -it --name my_ubuntu_container ubuntu:latest bash

这将创建并启动一个新的容器，你可以在其中执行命令和操作。

注意事项

确保你的Docker客户端已经安装并正确配置。
如果你在一个有网络限制的环境中，可能需要配置Docker以使用特定的镜像仓库或代理。
在某些情况下，你可能需要登录到Docker Hub或其他私有仓库才能拉取镜像。使用 docker login 命令来登录。
拉取镜像可能需要一些时间，具体取决于镜像的大小和你的网络速度。

通过上述步骤，你可以轻松地从Docker Hub或其他镜像仓库拉取所需的镜像，并在你的本地Docker环境中使用它们。

docker将容器打包为镜像

在Docker中，将正在运行的容器打包为镜像是一个常见的操作，这允许你保存对容器所做更改的快照，并在以后重新创建具有相同状态的容器。这个过程主要涉及到使用 docker commit 命令来创建新的镜像。下面是详细的步骤和一些额外的信息，以帮助你更好地理解这个过程：

1. 进入正在运行的容器

首先，你需要确定你想要打包的容器正在运行，并且你需要进入该容器。如果你没有在 docker exec 命令中指定 --user 选项，Docker会默认以root用户身份执行命令。你可以使用以下命令来进入容器：

docker exec -it <容器ID或名称> /bin/bash

这里，<容器ID或名称> 是你想要打包的容器的ID或名称。/bin/bash 是大多数Linux容器默认的shell。

2. 以管理员身份进入正在运行的容器

在Docker中，你可以使用 docker exec 命令来在正在运行的容器内执行命令。如果你需要以root用户身份进入容器，可以使用以下方法：

使用 docker exec 命令和 --user 选项

Docker允许你在 docker exec 命令中指定运行命令的用户。如果你想以root用户身份执行命令，可以将 --user 选项设置为 root。

例如，如果你想以root用户身份进入容器的shell，可以使用以下命令：

docker exec -it --user root <container_id_or_name> /bin/bash

这里的参数解释如下：

-it：这是两个连在一起的选项，-i 表示交互式模式，-t 分配一个伪终端。
--user root：指定运行命令的用户为root。
<container_id_or_name>：你想要进入的容器的ID或名称。
/bin/bash：你想要执行的命令，这里以bash shell为例。

3. 进行更改

在容器内部，你可以进行所需的更改，比如安装软件、修改配置文件、添加新文件等。

4. 退出容器

完成更改后，你需要退出容器。在bash中，你可以直接输入 exit 命令或者使用 Ctrl+D 快捷键。

5. 提交更改为新的镜像

现在，你可以使用 docker commit 命令将更改后的容器保存为新的镜像。命令格式如下：

docker commit -m="提交信息" -a="作者" <容器ID或名称> <新镜像名>:<tag>

-m 选项后面跟着的是提交信息，用于描述这次创建镜像的变更。
-a 选项后面跟着的是作者的名字。
<容器ID或名称> 是你想要打包的容器的ID或名称。
<新镜像名>:<tag> 是你为新创建的镜像指定的名称和标签（标签可以是版本号或其他标识）。

例如：

docker commit -m="Added new configuration" -a="YourName" my_container my_new_image:1.0

5. 验证新的镜像

提交完成后，你可以使用 docker images 命令来查看所有本地镜像，确认你的新镜像已经创建。

docker images

6. 创建并测试新的容器

最后，你可以使用新创建的镜像来运行一个新的容器，并验证更改是否按预期生效。

docker run -it --name new_container my_new_image:1.0 /bin/bash

在这个新容器中，你可以检查你的更改是否都已正确应用。

注意事项

打包容器为镜像时，所有的更改都会保存在新的镜像中，这意味着如果你在容器中删除了某些文件或做了其他不可逆的更改，这些更改也会被保存。
docker commit 命令创建的镜像只包含容器的文件系统更改，不会包含容器的运行状态或任何临时数据。
镜像的分层机制意味着每次提交都会创建一个新的层，这有助于节省空间和提高构建效率。

通过上述步骤，你可以轻松地将正在运行的容器打包为新的Docker镜像，并在需要时重新创建具有相同配置和数据的容器。

Docker导出镜像

在Docker中，导出镜像通常是指将镜像保存为一个tar文件，这样你可以将其移动到另一台机器上或者用作备份。以下是使用Docker导出镜像的步骤：

查找镜像ID或名称：首先，你需要知道你想要导出的镜像的名称或者ID。可以使用docker images命令来列出所有的镜像。
```
docker images
```
这将列出所有本地镜像及其相关信息，如镜像ID、名称、标签和大小等。
导出镜像：使用docker save命令来导出镜像。你需要指定镜像的名称或者ID。
```
docker save -o <文件名>.tar <镜像名或ID>
```
其中-o选项后跟你想要保存的文件名，<文件名>.tar是你想要创建的tar文件的名称，<镜像名或ID>是你想要导出的镜像的名称或者ID。
例如，如果你想要导出名为ubuntu的镜像，你可以执行：
```
docker save -o ubuntu.tar ubuntu:latest
```
这将创建一个名为ubuntu.tar的文件，包含了ubuntu:latest这个镜像的所有层和元数据。
验证导出：导出完成后，你可以使用ls命令来检查文件是否存在。
```
ls -lh <文件名>.tar
```
这将显示tar文件的详细信息，包括大小和权限等。
导入镜像（可选）：如果你想在另一台机器上导入这个镜像，可以使用docker load命令。
```
docker load -i <文件名>.tar
```
执行这个命令后，Docker将会读取tar文件并重新创建镜像。

请注意，导出的tar文件包含了镜像的所有层，这意味着如果你有多个标签指向同一个镜像，那么这些标签也会被包含在内。如果你只想导出特定的标签，确保在docker save命令中指定正确的标签。

运行、停止和启动Docker容器

在使用Docker进行容器管理时，停止和启动容器是常见的操作。以下是如何在不同操作系统上执行这些操作的步骤。

Docker run常用参数

docker run 命令用于创建并启动一个新的容器。

语法

docker run [OPTIONS] IMAGE [COMMAND] [ARG...]

常用参数说明：

-d: 后台运行容器并返回容器 ID。
-it: 交互式运行容器，分配一个伪终端。
--name: 给容器指定一个名称。
-p: 端口映射，格式为 host_port:container_port。
-v: 挂载卷，格式为 host_dir:container_dir。
--rm: 容器停止后自动删除容器。
--env 或 -e: 设置环境变量。
--network: 指定容器的网络模式。
--restart: 容器的重启策略（如 no、on-failure、always、unless-stopped）。
-u: 指定用户。

实例

1. 基本使用

docker run ubuntu:latest

拉取 ubuntu 镜像并在前台启动一个容器。ubuntu:latest中的latest为镜像的版本号或Tag号,例如ubuntu:14.04

2. 后台运行容器

docker run -d ubuntu:latest

在后台运行 ubuntu 容器并返回容器 ID。

3. 交互式运行并分配终端

docker run -it ubuntu:latest /bin/bash

以交互模式运行 ubuntu 容器，并启动一个 Bash shell。

4. 指定容器名称

docker run --name my_container ubuntu:latest

运行一个 ubuntu 容器，并将其命名为 my_container。

5. 端口映射

docker run -p 8080:80 nginx:latest

将本地主机的 8080 端口映射到容器内的 80 端口，运行 nginx 容器。

6. 挂载卷

docker run -v /host/data:/container/data ubuntu:latest

将主机的 /host/data 目录挂载到容器内的 /container/data 目录。注意此时/host/data 目录会在启动时覆盖容器内的 /container/data 目录

7. 设置环境变量

docker run -e MY_ENV_VAR=my_value ubuntu:latest

设置环境变量 MY_ENV_VAR 的值为 my_value，运行 ubuntu 容器。

8. 使用网络模式

docker run --network host nginx:latest

使用主机的网络模式运行 nginx 容器。

9. 指定重启策略

docker run --restart always nginx:latest

设置容器的重启策略为 always，即使容器停止也会自动重启。

10. 指定用户

docker run -u user123 ubuntu:latest

以 user123 用户运行 ubuntu 容器。

11. 组合多个选项

注意:在做nginx文件映射之前,需要先将nginx容器运行起来,把相关配置拷贝到宿主机映射目录,然后再删除nginx容器,最后重新运行nginx容器并进行文件映射.

docker run -d -p 8080:80 -v /host/data:/data --name webserver nginx:latest
# 例如：运行nginx:latest镜像的容器,并把配置文件和网站文件映射到主机
docker run -d --name nginx-official -p 8899:8899 -v /offcial-web/conf.d:/etc/nginx/conf.d  -v /offcial-web/html:/usr/share/nginx/html nginx:latest

后台运行一个命名为 webserver 的 nginx 容器，将主机的 8080 端口映射到容器的 80 端口，并将主机的 /host/data 目录挂载到容器的 /data 目录。

在Linux系统上停止和启动Docker容器

停止容器：使用docker stop命令可以停止一个或多个正在运行的容器。你需要提供容器的ID或名称作为参数。例如：
```
docker stop container_id_or_name
```
如果你想要停止多个容器，可以连续列出它们的ID或名称，用空格分隔：
```
docker stop container1_id container2_name container3_id
```
启动容器：要启动已经停止的容器，可以使用docker start命令。同样，需要提供容器的ID或名称。例如：
```
docker start container_id_or_name
```
和停止容器一样，你也可以一次启动多个容器。

在Windows系统上停止和启动Docker容器

对于Windows系统，如果你是通过Docker Desktop来管理Docker容器的，可以通过以下步骤操作：

停止容器：在Docker Desktop的应用界面中，找到你想要停止的容器，右键点击该容器，然后选择“Stop Container”选项。
启动容器：在Docker Desktop的应用界面中，找到已经停止的容器，右键点击该容器，然后选择“Start Container”选项。

在macOS系统上停止和启动Docker容器

macOS上的Docker操作和Linux类似，可以通过命令行来管理容器。

停止容器：打开终端，使用docker stop命令来停止容器：
```
docker stop container_id_or_name
```

启动容器：使用docker start命令来启动容器：

docker start container_id_or_name

注意事项

停止容器并不会删除容器，它只是将容器的状态从运行（running）变为停止（stopped）。容器的数据和状态都会被保留。
启动容器时，如果容器是以交互模式创建的，你可能需要使用docker attach命令来附加到容器。
如果你想要强制停止容器，可以在docker stop命令后添加-t参数来设置一个超时时间，例如docker stop -t 10 container_id_or_name，这会给容器10秒的时间来正常停止，否则会被强制停止。
在某些情况下，你可能需要先停止容器，然后再删除它。使用docker rm命令可以删除已经停止的容器。

通过上述步骤，你可以轻松地管理Docker容器的启动和停止操作。记得在操作时保持对容器状态的关注，以确保你的应用和数据安全。

docker删除镜像/容器

在使用Docker进行容器化应用管理时，有时需要删除不再需要的镜像或容器以释放资源。以下是如何在不同操作系统上执行这些操作的步骤。

删除Docker镜像

查看镜像列表：首先，你可以使用docker images命令查看当前系统中所有的镜像。
```
docker images
```
删除镜像：使用docker rmi命令来删除一个或多个镜像。你需要提供镜像的ID或名称作为参数。例如：
```
docker rmi image_id_or_name
```
如果镜像被容器使用，你需要先删除那些容器或者使用-f参数来强制删除镜像：
```
docker rmi -f image_id_or_name
```
你也可以一次删除多个镜像：
```
docker rmi image1_id image2_name
```

删除Docker容器

查看容器列表：使用docker ps命令查看当前系统中所有的容器，包括正在运行的和已停止的。
```
docker ps -a
```
删除容器：使用docker rm命令来删除一个或多个容器。你需要提供容器的ID或名称作为参数。例如：
```
docker rm container_id_or_name
```
如果容器正在运行，你需要先停止容器，或者使用-f参数来强制删除容器：
```
docker rm -f container_id_or_name
```
同样，你也可以一次删除多个容器：
```
docker rm container1_id container2_name
```

注意事项

在删除镜像之前，请确保没有任何容器正在使用该镜像。如果有，你需要先删除那些容器。
当你使用docker rmi命令删除镜像时，Docker会检查是否有容器依赖于该镜像。如果有，Docker会拒绝删除操作，除非你使用-f参数来强制删除。
在删除容器之前，如果你希望保留容器的数据，可以考虑将容器的文件系统导出为一个新的镜像，或者定期备份容器的数据卷。
删除操作是不可逆的，一旦执行，所有相关的数据和设置都将丢失。因此，在执行删除操作之前，请确保你不再需要这些镜像或容器。
如果你想要删除所有未被容器引用的镜像，可以使用docker image prune命令。同样，Docker也提供了docker container prune命令来删除所有已停止的容器。

通过上述步骤，你可以有效地清理Docker环境中不再需要的资源，以保持系统的整洁和高效运行。在执行删除操作时，请务必谨慎，确保不会误删重要的镜像或容器。

Docker推送镜像到私有仓库

确认镜像是否存在：首先，使用 docker images 命令来确认你的本地确实存在你想要推送的镜像。

登录到私有仓库：

docker login <IP>:<端口>

例如：

docker login 10.13.6.31:8080

标记镜像：使用 docker tag 命令为你的镜像添加一个新标签，这个标签应该包含你的私有仓库地址。命令格式如下：
```
docker tag <本地镜像名> <仓库地址>:<标签>
```
例如，如果你的镜像名为 my-image，并且你想将其推送到 10.13.6.31:8080 的hellow仓库，你可以使用以下命令：
```
docker tag my-image 10.13.6.31:8080/hellow/test-point:latest
```
这样就会为你的镜像创建一个新标签。
推送镜像：完成标记后，使用 docker push 命令将镜像推送到仓库：
```
docker push 10.13.6.31:8080/hellow/test-point:latest
```
确保在推送命令中使用完整的仓库地址和标签。

设置docker容器时间为UTC+8

查看服务器时间

在Docker容器中查看服务器时间可以通过多种方式实现，这取决于你的需求和容器的配置。以下是几种常见的方法：

使用date命令：在容器内部，你可以使用标准的Linux date命令来查看当前的时间和日期。例如：
```
docker exec <容器ID或名称> date
```
这个命令会在指定的容器中执行date命令，并显示结果。<容器ID或名称>是你想要查看时间的容器的ID或者名称。
查看宿主机时间：如果你想要查看运行容器的宿主机的时间，可以在宿主机上直接使用date命令：
```
date
```
这将显示宿主机的当前时间。
使用docker inspect命令：如果你想要查看容器的创建时间或者其他相关信息，可以使用docker inspect命令。这个命令会返回容器的详细配置和状态信息，包括创建时间（Created）：
```
docker inspect <容器ID或名称>
```
在输出的JSON数据中，你可以找到Created字段，它表示容器创建的时间戳。
查看Docker守护进程日志：如果你想要查看Docker守护进程启动的时间，可以查看其日志。这通常需要root权限，可以使用以下命令：
```
journalctl -u docker.service
```
这个命令会显示Docker服务的日志，你可以在其中找到服务启动的时间。
在Dockerfile中设置时间：如果你在构建镜像时想要设置特定的时间，可以在Dockerfile中使用ENV指令来设置环境变量，例如：
```
ENV TIMEZONE=Asia/Shanghai
```
然后在启动容器时，使用-e选项来设置环境变量：
```
docker run -e TIMEZONE=$TIMEZONE <镜像名>
```
这样，容器内部的时间将会根据你设置的时区进行调整。

请注意，容器内部的时间可能会受到宿主机时间的影响，因为容器通常使用宿主机的系统时间。如果你需要确保容器时间的准确性，可以考虑在容器启动时同步时间。

Docker设置容器时间

在Docker容器中设置时区是一个常见的需求，尤其是在跨地域部署应用时。如果你想要将Docker容器的时间设置为UTC+8，即东八区，你可以在运行容器时通过-e参数设置环境变量TZ来实现。

以下是具体的步骤：

使用docker run命令时设置时区：当你启动一个新的容器时，可以在docker run命令中加入-e TZ=Asia/Shanghai来设置时区为东八区（上海时间）。例如：
```
docker run -e TZ=Asia/Shanghai <其他选项> <镜像名>
```
这里的<其他选项>可以是其他你需要的参数，如端口映射、卷挂载等，<镜像名>是你想要运行的Docker镜像的名称。
在Docker Compose文件中设置时区：如果你使用Docker Compose来管理你的容器，可以在docker-compose.yml文件中为相应的服务设置环境变量。例如：
```
services:
  myservice:
    image: <镜像名>
    environment:
      - TZ=Asia/Shanghai
```
在这个例子中，myservice是你定义的服务名称，<镜像名>是你想要使用的镜像。
在Dockerfile中设置时区：你也可以在构建镜像的Dockerfile中设置时区。在Dockerfile中加入以下指令：
```
FROM <基础镜像>
ENV TZ=Asia/Shanghai
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
```
使用ENV指令来设置环境变量TZ，然后使用RUN指令来同步时区设置。
更新正在运行的容器时区：如果你想要更改一个已经运行的容器的时区，你需要先停止容器，然后使用-e参数重新启动它：
```
docker stop <容器ID或名称>
docker start -a -e TZ=Asia/Shanghai <容器ID或名称>
```
在这里，<容器ID或名称>是你想要更改时区的容器的ID或名称。

请注意，当你设置容器的时区时，确保你使用的是正确的时区标识符。Asia/Shanghai是东八区的标准时区标识符。通过这些方法，你可以确保你的Docker容器按照UTC+8时区运行。

如果上述方法不可行，可尝试如下方法：

1、查看docker容器中的时间：

docker exec <容器ID或名称> date

docker exec -it 容器名称或容器ID echo "Asia/Shanghai" > /etc/timezone

如果服务器系统时间有问题可以使用如下方法： 1、查看服务器时间：date 2、设置校正服务器时间：date -s "yyyy-mm-dd HH:mm:ss"，例如：date -s "2024-06-27 21:08:00"

Docker网络管理

在Docker中配置网络、添加容器到网络以及给容器指定IP地址是一个涉及多个步骤的过程。下面将详细解释这些步骤，以便更好地理解和应用。

检查现有的网络

首先，你需要检查当前 Docker 主机上存在的网络列表，看看是否有任何网络使用了相同的子网。你可以使用以下命令来列出所有网络：

docker network ls

删除现有的网络

如果你发现有一个或多个网络使用了与你在 docker-compose.yml 文件中指定的相同子网，你需要删除这些网络。你可以使用以下命令来删除一个特定的网络（替换 <network-name> 为目标网络的名称）：

docker network rm <network-name>

确保在删除网络之后，没有任何容器正在使用该网络。如果有，你需要先停止和删除那些容器。

1. 理解Docker网络模式

Docker支持多种网络模式，每种模式都有其特定的用途和配置方式。

桥接模式：默认模式，创建一个虚拟的网络，容器在该网络中获得独立的IP地址，容器之间以及与宿主机之间可以通信。
Host网络：容器共享宿主机的网络命名空间，容器的网络端口直接映射到宿主机上，没有隔离。
None网络：容器没有任何网络接口，适用于需要手动设置网络的情况。
Container模式：容器的网络栈与另一个容器共享，两者可以通信，但对于外部不可见。

创建自定义网络

自定义网络让你可以定义自己的子网和网关，从而更好地控制容器的网络环境。

步骤：

打开终端或命令行界面。
输入以下命令来创建一个新的自定义网络：
```
docker network create --driver bridge --subnet 172.28.0.0/16 --gateway 172.28.0.1 my_custom_network
```
这里，172.28.0.0/16是子网范围，172.28.0.1是网关地址，my_custom_network是网络的名称。

将容器添加到网络中

创建了自定义网络后，你可以在运行容器时将其加入到这个网络中。

步骤：

使用docker run命令启动新容器，并添加--network标志来指定网络：
```
docker run -d --name my_container --network my_custom_network my_image
```
这里，my_container是容器的名称，my_image是你要使用的Docker镜像。

给容器指定IP地址

在自定义网络中，你可以为容器指定一个固定的IP地址，而不是让Docker自动分配。

步骤：

在运行容器时，使用--ip标志来指定IP地址：
```
docker run -d --name my_container --network my_custom_network --ip 172.28.0.2 my_image
```
这里，172.28.0.2是你想要分配给容器的静态IP地址。

验证网络配置

运行容器后，你可以检查其网络配置来确认IP地址和其他网络设置是否正确。

步骤：

使用docker inspect命令查看容器的详细信息，包括网络配置：
```
docker inspect my_container
```
在输出的信息中，你可以找到网络部分，确认容器是否获得了指定的IP地址。

Docker-compose

运行docker-compose

假设在所需镜像已经load完毕，使用docker-compose.yml管理所需的全部容器。

在 Docker Compose 中，您可以为整个项目定义一个项目名称，同时为每个服务定义单独的服务名称。项目名称是您在执行 docker-compose 命令时使用的名称，而服务名称是您在 docker-compose.yml 文件中定义的。

在执行 docker-compose up 或 docker-compose down 等命令时，可以通过 -p 或 --project-name 参数指定一个项目名称。这个名称将用作默认的命名空间，用于创建的网络、卷和其他资源。-d参数指定在后台运行。

docker-compose -p my_project up -d

在这个例子中，my_project 就是项目名称。

如果你不需要在后台运行docker和指定项目名称，可以使用docker-compose up命令直接运行docker-compose.yml 文件。

使用Docker Compose配置网络

对于多容器应用，Docker Compose提供了一个简化的网络配置方法。

步骤：

在docker-compose.yml文件中定义服务和网络：

version: '3'
services:
  myservice:
    image: nginx
    networks:
      my_custom_network:
        ipv4_address: 172.28.0.2
networks:
  my_custom_network:
    ipam:
      driver: default
      config:
        - subnet: 172.28.0.0/16

这里，myservice是服务名称，nginx是使用的镜像，my_custom_network是自定义网络的名称，172.28.0.2是为服务指定的IP地址。

通过上述详细步骤，你可以在Docker中创建和管理自定义网络，将容器加入网络，并为容器指定静态IP地址。这有助于确保容器之间的通信按预期进行，并为容器化环境提供了更好的控制和可管理性。

Linux系统

服务器间文件传输

例如：要实现从服务器A（地址为172.18.110.36）的/dockers路径下加载镜像到服务器B，您可以按照以下步骤操作：

在服务器A上打包镜像：首先，您需要在服务器A上将所需的Docker镜像打包成一个tar文件。这可以通过Docker的save命令来完成。例如，如果您要打包名为my-image的镜像，可以使用以下命令：
```
sudo docker save -o /dockers/my-image.tar my-image:tag
```
这将会创建一个名为my-image.tar的文件，并将其保存在服务器A的/dockers目录下。
将镜像文件传输到服务器B：接下来，您需要将打包好的镜像文件从服务器A传输到服务器B。这可以通过SCP（Secure Copy Protocol）来安全地完成。使用以下命令：
```
scp /dockers/my-image.tar user@serverB_ip:/dockers/
```
其中user是服务器B上的用户名，serverB_ip是服务器B的IP地址。您需要替换为实际的用户名和IP地址。
在服务器B上加载镜像：一旦镜像文件成功传输到服务器B的/dockers目录下，您可以使用Docker的load命令来加载镜像。在服务器B上执行以下命令：
```
sudo docker load < /dockers/my-image.tar
```
这将会从my-image.tar文件中加载镜像到服务器B的Docker环境中。
验证镜像是否加载成功：加载完成后，您可以使用docker images命令来查看服务器B上的镜像列表，确认新加载的镜像是否出现在列表中：
```
sudo docker images
```
如果一切正常，您应该能在列表中看到my-image镜像。
scp命令默认情况下只能复制文件，不能递归地复制目录中的所有内容。您需要使用-r（递归）选项来递归复制整个目录及其内容。请尝试以下命令：
```
scp -r /temp/ root@172.18.110.36:/dockers
```

通过以上步骤，您就可以将服务器A上的Docker镜像传输并加载到服务器B上。确保在执行这些步骤时，您具有足够的权限来访问和操作服务器A和服务器B上的Docker环境。

常用的网络配置工具

ifconfig是一个常用的网络配置工具，它可以用来查看和配置网络接口的参数。不过，需要注意的是，ifconfig在一些Linux发行版中已经不再推荐使用，而是推荐使用ip命令来管理网络接口。

如果你确实需要在Linux系统中安装ifconfig，可以根据你所使用的Linux发行版来选择相应的安装方法。

对于基于Debian的系统（如Ubuntu）

ifconfig属于net-tools包。你可以使用以下命令来安装：

sudo apt-get update
sudo apt-get install net-tools

对于基于RPM的系统（如CentOS、Fedora）

ifconfig同样包含在net-tools包中。你可以使用以下命令来安装：

sudo yum install net-tools

或者，如果你使用的是dnf包管理器（在一些较新的Fedora版本和未来的CentOS版本中）：

sudo dnf install net-tools

对于Arch Linux

在Arch Linux及其衍生系统中，ifconfig同样可以通过net-tools包来安装：

sudo pacman -S net-tools

其他注意事项

安装完成后，你可以通过在终端输入ifconfig来检查是否安装成功。
虽然ifconfig仍然被广泛使用，但是考虑到其在一些系统中的弃用，建议学习并使用ip命令，它是当前推荐的网络管理工具，且更加强大和灵活。
在使用ifconfig或任何其他网络配置工具时，请确保你了解相关命令和操作的影响，以避免潜在的网络连接问题。

请根据你的操作系统选择合适的安装方法，并在执行任何网络配置更改之前确保你有足够的权限（通常需要root权限）。

Debian系统网络实时情况

要查看Debian系统上eth0网卡的网络实时占用情况，你可以使用iftop或nload这样的工具。这些工具提供了一个实时的视图，显示网络接口的数据传输情况。

首先，你需要安装这些工具。以下是安装和使用它们的步骤：

安装 `iftop`

使用apt包管理器安装iftop：

sudo apt update
sudo apt install iftop

运行iftop来监控eth0网卡的网络使用情况：

sudo iftop -i eth0

iftop会显示一个实时更新的列表，其中包括了所有通过eth0网卡的网络连接和它们的数据传输速率。

安装 `nload`

使用apt包管理器安装nload：

sudo apt update
sudo apt install nload

运行nload来监控网络接口：

nload

nload会在终端中显示两个图表，分别表示上传和下载的速度。你可以通过按e键（或者⬅/➡）来选择监控特定的网卡，比如eth0。

编写Shell脚本

如果你想要一个自动化的解决方案，可以编写一个简单的Shell脚本，当你需要时只需运行它即可查看eth0网卡的实时网络占用情况。

创建一个名为monitor_eth0.sh的脚本文件，并使用文本编辑器打开它：

nano monitor_eth0.sh

然后，将以下内容复制到脚本文件中：

#!/bin/bash

# Check if iftop is installed
if ! command -v iftop &> /dev/null
then
    echo "iftop could not be found. Attempting to install it..."
    sudo apt update
    sudo apt install -y iftop
fi

# Run iftop for eth0
sudo iftop -i eth0

保存并关闭文件。然后，给脚本文件执行权限：

chmod +x monitor_eth0.sh

现在，你可以通过运行以下命令来使用这个脚本：

./monitor_eth0.sh

这个脚本会检查iftop是否已经安装，如果没有安装，它会尝试安装iftop，然后运行iftop来监控eth0网卡的网络使用情况。

请注意，iftop和nload可能不会在所有版本的Debian中默认可用，如果你遇到任何问题，可能需要查找你的Debian版本的特定软件仓库或者使用第三方仓库来安装这些工具。

查看当前系统信息

查看当前系统信息的方法取决于你使用的操作系统。以下是一些常见操作系统中查看系统信息的方法：

在Linux系统中查看系统信息

使用uname命令：
```
uname -a
```
这个命令会显示内核版本、主机名、内核构建日期和时间、当前运行的处理器类型等信息。
查看系统资源使用情况：
- 使用top命令查看实时的系统资源使用情况，包括CPU、内存等：
```
top
```
- 使用htop命令（需要先安装）来获取一个更友好的界面：
```
htop
```
查看系统硬件信息：
- 使用lscpu命令查看CPU信息：
```
lscpu
```
- 使用lsblk命令查看磁盘和分区信息：
```
lsblk
```
- 使用free命令查看内存使用情况：
```
free -h
```
查看操作系统版本：
- 使用cat命令查看/etc/os-release文件，了解操作系统版本信息：
```
cat /etc/os-release
```

在Windows系统中查看系统信息

使用任务管理器：
- 按Ctrl + Shift + Esc打开任务管理器，查看CPU、内存、磁盘等资源使用情况。
- 在“性能”标签页下，可以查看详细的硬件和资源使用信息。
使用系统信息工具：

按Win + R打开“运行”对话框，输入msinfo32并回车，打开“系统信息”工具，查看详细的系统硬件和软件配置信息。

使用命令提示符或PowerShell：
- 打开命令提示符或PowerShell，输入systeminfo命令查看系统概述信息：
```
systeminfo
```
- 使用wmic命令查询系统信息，例如查看CPU信息：
```
wmic cpu get name, description, numberofcores
```

在macOS系统中查看系统信息

关于本机：
- 点击屏幕左上角的苹果菜单，选择“关于本机”，查看系统版本、处理器、内存等信息。
使用终端：
- 打开终端，输入uname -a查看系统内核信息。
- 输入top查看实时的系统资源使用情况。

通过上述方法，你可以查看到当前系统的详细信息，包括操作系统版本、硬件配置、资源使用情况等。这些信息对于系统管理和故障排查都是非常有用的。

设置服务器时间同步NTP

在 Linux 服务器上实现时间同步，主流且推荐的做法是部署 chrony 服务，它兼具精度高、收敛快、对虚拟化/云环境友好等优点；若环境极简或仅需一次性校准，也可选用 ntpdate 或 systemd-timesyncd。下面给出三种常见方案的操作步骤与注意事项，供按场景取舍。

一、chrony（持续同步，生产环境首选）

安装 CentOS/RHEL 系统执行：

yum -y install chrony

Debian/Ubuntu 系统执行：

apt install chrony

编辑配置文件 CentOS/RHEL 系统执行:

vim /etc/chrony.conf

Debian/Ubuntu 系统执行:

vim /etc/chrony/chrony.conf

把默认 server 注释掉，加入国内高质量源（示例）：

server ntp.aliyun.com iburst minpoll 4 maxpoll 10
server ntp1.tencent.com iburst
server ntp2.tencent.com iburst

启动并设为开机自启

systemctl enable --now chronyd

查看同步状态 chronyc tracking # 本地时钟偏差、参考源等 chronyc sources -v # 各源层级、延迟、偏差

二、ntpdate（一次性手动校准，适合初始化/应急）

安装 yum -y install ntpdate 或 apt install ntpdate

强制同步（立即生效，需 root）

ntpdate -u <NTP服务器地址>

示例：

ntpdate -u ntp.aliyun.com      # -u 表示使用 123/UDP 不受限端口

写入硬件时钟，防止重启失效 hwclock -w

若需周期性校准，可写 cron：

echo '0 * * * * /usr/sbin/ntpdate -u ntp.aliyun.com && /sbin/hwclock -w' | crontab

三、systemd-timesyncd（极简，无 chrony 时备选）

启用服务 timedatectl set-ntp true # 一键开启配置文件 /etc/systemd/timesyncd.conf 里可写：
```
[Time]
NTP=ntp.aliyun.com ntp1.tencent.com
FallbackNTP=ntp.ubuntu.com
```
查看状态 timedatectl status # 若 “System clock synchronized: yes” 即成功

四、通用注意点

时区一致性： timedatectl set-timezone Asia/Shanghai
云主机若控制台自带“时间同步”插件，请先关闭，以免与自建 NTP 冲突。
防火墙放行 123/UDP： firewall-cmd --permanent --add-service=ntp && firewall-cmd --reload
数据库、日志、集群等场景，尽量避免大跨度跳时间；chrony 的 makestep 参数可控制允许步进/平滑纠正策略。

Nignx服务

Nginx是一款轻量级的Web服务器/反向代理服务器及电子邮件（IMAP/POP3）代理服务器，它以其高性能、稳定性、丰富的功能集、简单的配置和低资源消耗而闻名。以下是在Linux系统上安装、启动、停止Nginx服务器以及部署网站的步骤。

安装Nginx

步骤：

更新软件包列表：
```
sudo apt-get update
```
这一步是为了确保你的包管理器拥有最新的软件包信息。
安装Nginx：
```
sudo apt-get install nginx
```
这将从官方仓库中安装最新稳定版的Nginx。

启动Nginx

步骤：

启动Nginx服务：
```
sudo systemctl start nginx
```
使用systemctl命令来启动Nginx服务。
确认Nginx是否启动成功：
```
sudo systemctl status nginx
```
这个命令会显示Nginx服务的状态。如果Nginx正在运行，你会看到active (running)的状态。

停止Nginx

步骤：

停止Nginx服务：
```
sudo systemctl stop nginx
```
使用systemctl命令来停止Nginx服务。

重启Nginx

步骤：

重启Nginx服务：
```
sudo systemctl restart nginx
```
这个命令会停止Nginx服务然后再重新启动它，适用于你对Nginx配置文件做了更改后需要应用更改的情况。
如果你的系统没有使用Systemd，重启Nginx的命令可能会有所不同。在一些旧的系统上，你可能需要使用service命令：
```
sudo service nginx restart
```
或者，你也可以直接使用nginx命令来重新加载配置文件，这不会中断现有的连接：
```
sudo nginx -s reload
```
这条命令会检查Nginx配置文件的语法是否正确，并平滑地重启Nginx，应用新的配置。

部署网站

步骤：

配置网站：
- 编辑Nginx的配置文件，通常位于/etc/nginx/sites-available/目录下。
- 创建一个新的配置文件，例如mywebsite.conf，并设置你的网站信息，如服务器块（server block）和根目录（root directory）。
- 例如：
```
server {
    listen 80;
    server_name example.com www.example.com;
    root /var/www/html;
    index index.html index.htm;

    location / {
        try_files $uri $uri/ =404;
    }
}
```
- 在这个例子中，listen指令设置了服务器监听的端口（这里是80），server_name定义了域名，root指定了网站文件的存放目录。
创建符号链接：
- 为了让Nginx找到你的配置文件，你需要在/etc/nginx/sites-enabled/目录下创建一个指向你的配置文件的符号链接。
- 使用ln命令：
```
sudo ln -s /etc/nginx/sites-available/mywebsite.conf /etc/nginx/sites-enabled/
```
测试配置文件：
- 在重启Nginx之前，使用nginx -t命令来测试配置文件是否有语法错误。
```
sudo nginx -t
```
重启Nginx：
- 如果配置文件没有错误，重启Nginx使更改生效。
```
sudo systemctl restart nginx
```
上传网站文件：
- 将你的网站文件上传到之前在配置文件中指定的目录（例如/var/www/html）。

你可以使用FTP、SCP或者任何文件管理器来上传文件。

检查网站：
- 在浏览器中输入你的域名，检查网站是否成功部署。

通过上述步骤，你可以在Nginx服务器上安装Nginx、管理服务状态，并部署你的网站。确保在编辑配置文件时遵循正确的语法，并且在每次更改配置后都要重新加载或重启Nginx服务。

nignx配置示例

server {
        listen      8888 ssl;
        server_name  localhost;
        
        ssl_certificate /etc/nginx/conf.d/172.18.110.32_8888_ssl.crt;
        ssl_certificate_key /etc/nginx/conf.d/172.18.110.32_8888_key.private;

        # ssl的一些配置
        ssl_session_cache    shared:SSL:1m;
        ssl_session_timeout  5m;
        ssl_prefer_server_ciphers  on;
        ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE:ECDH:AES:HIGH:!NULL:!aNULL:!MD5:!ADH:!RC4;
        ssl_protocols TLSv1 TLSv1.1 TLSv1.2; #开启TLS协议
#       location / {
#        # 允许来自 http://b.com 的跨域请求
#        add_header 'Access-Control-Allow-Origin' 'https://172.18.110.32:8888/vr-web/test.html';
#        add_header 'Access-Control-Allow-Methods' 'GET, POST, OPTIONS';
#        add_header 'Access-Control-Allow-Headers' 'DNT,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Range,Cookie';
#        # ... 其他配置 ...
#    }
        
        location /vr-web {
            alias   /usr/share/nginx/html/exam-web;
            index  index.html index.htm;
        }
    
     location /sz-web {
            alias   /usr/share/nginx/html/sz-web/dist;
            index  index.html index.htm;
       try_files $uri $uri/ /sz-web/index.html;
        }

 location /admin-web {
            alias   /usr/share/nginx/html/admin-web/dist;
            index  index.html index.htm;
           try_files $uri $uri/ /admin-web/index.html;
        }



        location /vr-emu {
            alias /usr/share/nginx/html/vr-web/;
            index index.html;


        }
        
        location /exam-api {
            proxy_pass       http://127.0.0.1:8100;
            proxy_set_header X-Real-PORT $remote_port;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-For $remote_addr;
            client_max_body_size 1000m;

        }

            location /vr-api {
                proxy_pass       http://127.0.0.1:8088;
                proxy_set_header Host $host:$server_port;
                proxy_set_header X-Real-IP $remote_addr;
                proxy_set_header X-Real-PORT $remote_port;
                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                client_max_body_size 1000m;
        }
        
         location /shenzhen {
                        proxy_pass       http://127.0.0.1:9090;
                        proxy_set_header X-Real-PORT $remote_port;
                        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                        proxy_set_header X-Forwarded-For $remote_addr;
                        client_max_body_size 1000m;

                }
                
         # 使用通配符匹配所有请求，并将它们重写为 /api 前缀
        location /api {
            rewrite ^/api/(.*)$ /$1 break;
            proxy_pass http://192.168.124.84:8742;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header Host $http_host;
            client_max_body_size 1000m;
        }
        
        # location /api ：使用/api路径来匹配所有/api进入的请求。
        # rewrite 指令：将请求路径中的 /api/ 部分重写掉，这样 Nginx 就会将剩余的路径传递给 proxy_pass 指定的上游服务器。
        # proxy_pass：将重写后的请求转发到 http://192.168.124.84:8742。
        # proxy_set_header：设置代理请求的头部信息。
        
        
        # 定义一个location来匹配对/images/的请求，以便通过HTTP访问服务器上/file-server/images/路径下的图片资源
        # 确保不要将location / 设置在 /images/ 之前，因为location的匹配有优先级
        # 以下是使用nginx搭建静态资源服务器的配置示例
        location /images/ {
            # 使用alias指令将请求的/images/路径映射到服务器上的文件路径
            alias /file-server/images/; # 静态资源文件夹的路径
            autoindex on; # 开启目录浏览功能，用户可以浏览文件夹内容
        }
        
    }

多端口监听配置示例：

server {
    listen       80;
    listen  [::]:80;
    server_name  localhost;
    #access_log  /var/log/nginx/host.access.log  main;
    location / {
        root   /usr/share/nginx/html;
        index  index.html index.htm;
    }
        #    location /file/ {
        #        alias /home/; # 指向容器内部的挂载点
        #    }
        #bw_manager文件映射路径
        
     location /profile/ {
                    alias /home/ruoyi/uploadPath/; 
    }
        
        #bw_player 前台文件映射路径
         location /bw_player/ {
                alias /home/ruoyi/uploadPath/;
    }
#    location /profile/ {
#        alias /home/ruoyi/uploadPath; # 指向容器内部的挂载点
#        autoindex on;
#    }
    
    #error_page  404              /404.html;

    # redirect server error pages to the static page /50x.html
    #
    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   /usr/share/nginx/html;
    }

    # proxy the PHP scripts to Apache listening on 127.0.0.1:80
    #
    #location ~ \.php$ {
    #    proxy_pass   http://127.0.0.1;
    #}

    # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
    #
    #location ~ \.php$ {
    #    root           html;
    #    fastcgi_pass   127.0.0.1:9000;
    #    fastcgi_index  index.php;
    #    fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;
    #    include        fastcgi_params;
    #}

    # deny access to .htaccess files, if Apache's document root
    # concurs with nginx's one
    #
    #location ~ /\.ht {
    #    deny  all;
    #}
}


# 学生端
server {
    listen       9090;
    listen  [::]:9090;
    server_name  localhost;

    #access_log  /var/log/nginx/host.access.log  main;

    location / {
        root /usr/share/nginx/html/exam;
        index  index.html index.htm;
        try_files $uri $uri/ /index.html;
    }
    
    location /api {
        rewrite ^/api/(.*)$ /$1 break;
        proxy_pass      http://172.28.0.6:8741;
        proxy_set_header X-Real-PORT $remote_port;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-For $remote_addr;
        client_max_body_size 1000m;
    }
    
     location /prod-api {
        rewrite ^/prod-api/(.*)$ /$1 break;
        proxy_pass      http://172.28.0.4:8576;
        proxy_set_header X-Real-PORT $remote_port;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-For $remote_addr;
        client_max_body_size 1000m;
    }
    
     #bw_manager文件映射路径
    location /profile/ {
                    alias /home/ruoyi/uploadPath/; 
    }
        
    #bw_player 前台文件映射路径
    location /bw_player/ {
                alias /home/ruoyi/uploadPath/;
    }
    #error_page  404              /404.html;

    # redirect server error pages to the static page /50x.html
    #
    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   /usr/share/nginx/html;
    }
}

# 管理端
server {
    listen       9091;
    listen  [::]:9091;
    server_name  localhost;

    #access_log  /var/log/nginx/host.access.log  main;

    location / {
        root   /usr/share/nginx/html/admin;
        index  index.html index.htm;
        try_files $uri $uri/ /index.html;
    }
    
    location /api {
        rewrite ^/api/(.*)$ /$1 break;
        proxy_pass      http://172.28.0.6:8741;
        proxy_set_header X-Real-PORT $remote_port;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-For $remote_addr;
        client_max_body_size 1000m;
    }
    
    location /prod-api {
        rewrite ^/prod-api/(.*)$ /$1 break;
        proxy_pass      http://172.28.0.4:8576;
        proxy_set_header X-Real-PORT $remote_port;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-For $remote_addr;
        client_max_body_size 1000m;
    }
    
    #bw_manager文件映射路径
    location /profile/ {
                    alias /home/ruoyi/uploadPath/; 
    }
        
    #bw_player 前台文件映射路径
    location /bw_player/ {
                alias /home/ruoyi/uploadPath/;
    }
    #error_page  404              /404.html;

    # redirect server error pages to the static page /50x.html
    #
    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   /usr/share/nginx/html;
    }
}

http转https

OpenSSL 是一个功能丰富且开源的安全工具箱，它提供 SSL/TLS 协议的实现、加密算法库、证书生成和管理工具等。它支持多种操作系统，包括 Linux、UNIX、Windows 和 Mac，采用 C 语言开发，具有跨平台性能。OpenSSL 的主要组件包括命令行工具 openssl、加密算法库 libcrypto 和 SSL 应用库 libssl。

安装 OpenSSL

安装 OpenSSL 的方法主要有两种：

直接下载安装包：可以访问官方网站或其他可信的第三方网站下载编译好的二进制文件进行安装。例如，可以在 http://slproweb.com/products/Win32OpenSSL.html 找到适用于 Windows 的安装包。
从源码编译安装：如果需要特定配置或想获取最新版本，可以从 OpenSSL 官网下载源码，然后根据系统环境自行编译安装。编译过程可能需要一些开发工具和库，例如在 Windows 上可能需要 Visual Studio 和 Perl 等。

对于 Windows 系统，安装 OpenSSL 的基本步骤通常包括：

下载适用于 Windows 的 OpenSSL 安装包。
运行下载的安装程序，按照提示完成安装。
安装过程中，可能需要选择安装路径和配置环境变量，以便在命令行中直接调用 OpenSSL 工具。
安装完成后，可以通过在命令行中输入 openssl version 来验证是否安装成功。

对于 Linux 系统，可以使用包管理器来安装 OpenSSL，例如在 CentOS 7 上可以使用以下命令：

yum install openssl openssl-devel

这将安装 OpenSSL 及其开发文件。

按照以下步骤操作：

生成自签名证书和私钥

首先，您需要生成一个自签名证书和一个私钥。您可以使用OpenSSL来完成这一步：

openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /etc/nginx/ssl/nginx-selfsigned.key -out /etc/nginx/ssl/nginx-selfsigned.crt

在这个命令中：

/etc/nginx/ssl/nginx-selfsigned.key 是生成的私钥的路径。
/etc/nginx/ssl/nginx-selfsigned.crt 是生成的自签名证书的路径。
-days 365 表示证书有效期为365天。

执行这个命令后，系统会提示您输入一些信息，比如国家、州、省、市、组织、组织单位、通用名称（Common Name，通常是域名）和电子邮件地址。这些信息会被嵌入到证书中。

创建一个Diffie-Hellman参数文件（可选但推荐）：
这个文件用于提高SSL连接的安全性：
```
openssl dhparam -out /etc/nginx/ssl/dhparam.pem 2048
```

配置Nginx使用自签名证书：

编辑Nginx配置文件（通常位于 /etc/nginx/nginx.conf 或 /etc/nginx/sites-available/default），添加以下内容：

server {
    listen 443 ssl;
    server_name your_domain.com;

    ssl_certificate /etc/nginx/ssl/nginx-selfsigned.crt;
    ssl_certificate_key /etc/nginx/ssl/nginx-selfsigned.key;

    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_prefer_server_ciphers on;
    ssl_dhparam /etc/nginx/ssl/dhparam.pem;

    ssl_ciphers 'ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384';

    location / {
        root /var/www/html;
        index index.html index.htm;
    }
}

server {
    listen 80;
    server_name your_domain.com;

    location / {
        return 301 https://$host$request_uri;
    }
}

listen 443 ssl; 指定服务器监听443端口（HTTPS）。
ssl_certificate 和 ssl_certificate_key 指定证书和私钥文件的位置。
ssl_dhparam 指定Diffie-Hellman参数文件的位置（如果已生成）。
第二个 server 块将HTTP请求重定向到HTTPS。

测试Nginx配置：
在重新加载或重启Nginx之前，测试配置是否正确：
```
sudo nginx -t
```
重新加载Nginx：
如果测试通过，重新加载Nginx使配置生效：
```
sudo systemctl reload nginx
```

按照这些步骤操作后，您的Nginx服务器将使用自签名证书支持HTTPS请求访问。访问您的域名时，浏览器会警告证书不是由受信任的机构签署，因为它是自签名证书。这在测试环境中是可以接受的，但在生产环境中应该使用受信任的证书颁发机构（CA）签发的证书。

Vue3.0

vue3.0路由守护

在Vue.js项目中，你可以使用Vue Router来创建路由，并结合Vue的生命周期钩子或者路由守卫来实现在用户未登录时拦截并跳转到登录页面的功能。以下是一个简单的示例，展示如何设置Vue Router以实现这一需求。

首先，确保你已经安装了Vue Router。如果还没有安装，可以通过以下命令安装：

npm install vue-router

然后，在你的Vue项目中设置路由。通常，你会在src目录下创建一个名为router.js或router/index.js的文件。在这个文件中，你可以定义你的路由规则和守卫。

// src/router/index.js
import Vue from 'vue'
import VueRouter from 'vue-router'
import Home from '../views/Home.vue'
import Login from '../views/Login.vue'
import Dashboard from '../views/Dashboard.vue'

Vue.use(VueRouter)

const routes = [
  {
    path: '/',
    name: 'Home',
    component: Home
  },
  {
    path: '/login',
    name: 'Login',
    component: Login
  },
  {
    path: '/dashboard',
    name: 'Dashboard',
    component: Dashboard,
    meta: { requiresAuth: true } // 标记需要验证的路由
  }
]

const router = new VueRouter({
  mode: 'history',
  base: process.env.BASE_URL,
  routes
})

// 全局前置守卫
router.beforeEach((to, from, next) => {
  // 检查是否需要登录的路由
  if (to.matched.some(record => record.meta.requiresAuth)) {
    // 检查用户是否已登录
    const isLoggedIn = localStorage.getItem('isLoggedIn') === 'true' // 假设你用localStorage来存储登录状态
    if (!isLoggedIn) {
      // 如果未登录，重定向到登录页面
      next({ path: '/login' })
    } else {
      // 如果已登录，允许访问
      next()
    }
  } else {
    // 如果不需要登录，直接放行
    next()
  }
})

export default router

在上述代码中，我们定义了一个名为requiresAuth的路由元数据，用于标记需要验证的路由。然后，我们使用router.beforeEach全局前置守卫来检查用户是否已经登录。如果用户未登录且尝试访问需要验证的路由，他们将被重定向到登录页面。

在你的Vue组件中，你可以使用router实例来导航到不同的页面，例如：

// 在某个组件中
export default {
  methods: {
    goToDashboard() {
      this.$router.push('/dashboard')
    }
  }
}

确保在你的Vue实例中引入并使用这个路由配置：

// src/main.js
import Vue from 'vue'
import App from './App.vue'
import router from './router'

Vue.config.productionTip = false

new Vue({
  router,
  render: h => h(App),
}).$mount('#app')

这样，你就设置了一个基本的路由系统，它会在用户未登录时拦截他们并重定向到登录页面。记得在你的登录逻辑中更新localStorage来标记用户登录状态。

Vite

vite5.0跨域配置

网络请求封装的基础地址如下：

const BaseURL = "/api";   // 若BaseURL地址是前端所在服务器地址，则const BaseURL = " "即可

vite.config.js配置代码如下：

// vite.config.js
 server: {
    //用来配置跨域
    host: '0.0.0.0',
    port: 80,
    proxy: {
      '/api': {
        target: 'http://192.168.023.05:8080',//目标服务器地址
        changeOrigin: true,
        rewrite: (path) => path.replace(/^\/api/, '')
      },
    }
  }

Git版本管理工具

基本用法

推送当前分支到远程仓库
```
git push
```
如果你已经配置了默认的远程仓库（通常是 origin）和分支（例如 main 或 master），这个命令会将本地分支的更改推送到对应的远程分支。

推送指定分支到远程仓库

git push origin <branch-name>

将本地的 <branch-name> 分支推送到远程仓库的同名分支。例如：

git push origin master
# 如果你的绑定的远端仓库不是origin，则使用你的远端仓库名称，例如：你当前绑定的远端仓库是my-origin
git push my-origin master

推送所有分支到远程仓库
```
git push --all origin
```
这会将本地的所有分支推送到远程仓库。
推送标签到远程仓库
```
git push origin <tag-name>
```
将指定的标签推送到远程仓库。如果要推送所有标签，可以使用：
```
git push --tags origin
```

常见选项

--force 或 -f 如果远程分支的内容与本地分支不一致（例如远程分支有额外的提交），Git 会拒绝推送。此时可以使用 --force 强制推送：
```
git push --force origin <branch-name>
```
注意：强制推送会覆盖远程分支的内容，可能会导致其他协作者的工作丢失，使用时需谨慎。
--force-with-lease 这是一个更安全的强制推送选项。它会在推送之前检查远程分支是否有新的更改，如果有，则拒绝推送：
```
git push --force-with-lease origin <branch-name>
```
--set-upstream 或 -u 设置本地分支与远程分支的关联关系，方便后续直接使用 git push 和 git pull：
```
git push -u origin <branch-name>
```

推送前的准备工作

在执行 git push 之前，建议先执行以下操作：

检查状态
```
git status
```
确保所有更改都已经提交。
拉取远程分支的最新更改 如果远程分支有新的提交，建议先拉取最新更改，避免冲突：
```
git pull origin <branch-name>
```
解决冲突 如果拉取后出现冲突，需要手动解决冲突后再次提交。

删除远端分支

在Git中，我们可以使用以下命令删除远程分支：

git push <远程仓库名称> --delete <分支名称>

示例：删除远程分支:

假设我们的项目有一个名为feature/branch1的远程分支，我们决定不再需要该分支，并希望将其删除。要删除这个分支，我们可以通过以下命令执行：

git push origin --delete feature/branch1

查看当前绑定的远程仓库列表

打开终端或命令提示符。
切换到你的本地Git仓库目录，使用cd命令，例如：
```
cd /path/to/your/repository
```
输入以下命令来查看远程仓库列表：
```
git remote -v
```
这个命令会显示所有的远程仓库，以及它们的URL和相关的操作（如fetch、push等）。

添加一个新的远程仓库

使用 git remote add 命令来添加一个新的远程仓库。你需要指定一个简短的名称（通常是 origin，但也可以是其他名称）和一个 URL。

git remote add origin <URL>

这里的 <URL> 是你的远程仓库地址，例如 https://github.com/username/repo.git。

删除当前绑定的远程仓库

一旦你查看了远程仓库列表并确定了要删除的远程仓库的名称，你可以使用以下命令来删除它：

git remote remove <remote_name>

<remote_name> 是你想要删除的远程仓库的名称。
例如，如果你想要删除名为origin的远程仓库，你可以执行：
```
git remote remove origin
```
执行这个命令后，该远程仓库将从你的本地Git配置中被移除。

Python

pip 国内镜像安装

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple -r requirements.txt

安装时若遇到SSL问题，可尝试使用如下http源进行安装：

pip install xxx-package -i http://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com
pip install xxx-package -i http://pypi.doubanio.com/simple/ --trusted-host pypi.doubanio.com

清华镜像地址：https://pypi.tuna.tsinghua.edu.cn/simple

例如，假设要安装 numpy 库，则在原来的语句上添加 -i 和镜像地址即可

pip install numpy -i https://pypi.tuna.tsinghua.edu.cn/simple

其他国内源：

阿里云：http://mirrors.aliyun.com/pypi/simple/

中国科技大学 https://pypi.mirrors.ustc.edu.cn/simple/

华中理工大学：http://pypi.hustunique.com/

山东理工大学：http://pypi.sdutlinux.org/

豆瓣：http://pypi.douban.com/simple/

生成requirements.txt文件

整个环境下的安装包都保存到requirements.txt中,使用如下命令

pip freeze > requirements.txt

CentOS服务器安装Python3.10

在 CentOS 系统上安装 Python 3.10 可能需要一些额外的步骤，因为 CentOS 的软件仓库默认可能不包含 Python 3.10。以下是在 CentOS 上安装 Python 3.10 的步骤：

1. 安装依赖

首先，你需要安装一些基本的开发工具和库，这些是编译 Python 所必需的：

sudo yum groupinstall "Development Tools"
sudo yum install zlib-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel libffi-devel

2. 下载 Python 3.10

接下来，你需要从 Python 官网下载 Python 3.10 的源代码：

wget https://mirrors.aliyun.com/python-release/source/Python-3.10.8.tgz

请检查 Python 官网以获取最新的版本和下载链接。

3. 解压源代码

解压下载的文件：

tar -xf Python-3.10.8.tgz
cd Python-3.10.8

4. 配置和编译 Python

配置 Python 并准备编译：

./configure --enable-optimizations --with-ssl

这个命令会检查系统环境并配置 Python。--enable-optimizations 选项会启用一些优化，这可能会使 Python 运行得更快，但会增加编译时间。

5. 编译并安装 Python

编译 Python 并安装到系统中：

sudo make altinstall

使用 altinstall 而不是 install 是为了避免覆盖系统默认的 Python 版本。

6. 验证安装

安装完成后，你可以通过以下命令验证 Python 版本：

python3.10 --version

这应该会显示 Python 3.10.8，表明 Python 3.10 已成功安装。

7. 设置默认 Python 版本（可选）

如果你想将 python3 命令指向新安装的 Python 3.10，你可以修改 /etc/alternatives：

sudo alternatives --config python3

然后选择 Python 3.10 作为默认版本。

注意事项

确保你的 CentOS 系统是最新的，或者至少是 Python 3.10 支持的版本。
编译 Python 可能需要一些时间，具体取决于你的系统性能。
如果你使用的是 CentOS 8 或更高版本，可能需要启用 PowerTools 仓库来获取一些依赖。
其他问题，例如SSL请参考博客：centos7安装python3.10及以上版本最佳步骤（不踩openssl的坑）_centos 安装python3.10-CSDN博客

python虚拟环境

1. 创建虚拟环境

虚拟环境是一个独立的目录树，包含特定版本的 Python 解释器和额外的包。使用虚拟环境可以避免全局 Python 环境的污染，并且可以为每个项目单独管理依赖。

创建虚拟环境的步骤：

选择一个目录来存放虚拟环境。例如，创建一个名为 myenv 的虚拟环境：
```
python3.10 -m venv myenv
```
这将创建一个名为 myenv 的目录，其中包含一个独立的 Python 环境。
激活虚拟环境：
- 在 Unix 或 macOS 上：
```
source myenv/bin/activate
```
- 在 Windows 上：
```
myenv\Scripts\activate
```
激活虚拟环境后，你的 shell 提示符会显示虚拟环境的名称，例如：
```
(myenv) $
```

2. 在虚拟环境中使用 pip

在虚拟环境中，pip 会自动安装包到虚拟环境的目录中，而不会影响全局 Python 环境。

安装包：

(myenv) $ pip install fastapi

升级包：

(myenv) $ pip install --upgrade fastapi

卸载包：

(myenv) $ pip uninstall fastapi

查看已安装的包：

(myenv) $ pip list

生成 requirements.txt 文件：

(myenv) $ pip freeze > requirements.txt

从 requirements.txt 安装包：

(myenv) $ pip install -r requirements.txt

3. 退出虚拟环境

当你完成工作后，可以通过以下命令退出虚拟环境：

(myenv) $ deactivate

这将恢复到全局 Python 环境。

* centos7安装python3.10及以上版本最佳步骤

1.安装预备环境

#安装源码编译需要的编译环境
yum install gcc zlib zlib-devel libffi libffi-devel make
yum install bzip2-devel xz-devel sqlite-devel tk-devel uuid-devel ncurses-devel
#解决后期出现的方向键、删除键乱码问题
yum install -y readline-devel
#
yum install -y wget

2.安装openssl

# openssl所需要的依赖
yum -y install perl perl-CPAN
#安装 IPC::Cmd模块,此过程会有几次交互，直接按y即可
cpan IPC::Cmd
#下载openssl
wget https://www.openssl.org/source/openssl-3.0.14.tar.gz  #此处若无法下载，可尝试手动打开链接，科学上网下载，然后传入服务器中解压
#解压
tar -xzvf openssl-3.0.14.tar.gz
#配置
cd openssl-3.0.14
./config --prefix=/usr/local/openssl3.0.14 --libdir=lib --openssldir=/etc/ssl
#编译
make -j1 depend
make -j8
#安装
make install_sw

3.安装python

#解压
tar -zxvf Python-3.10.8.tgz
#配置
cd Python-3.10.8
./configure --with-openssl=/usr/local/openssl3.0.14 --with-openssl-rpath=auto --prefix=/usr/local/python3.10
#编译
make -j8
#安装
make altinstall
#建软链
ln -s /usr/local/python3.10/bin/python3.10 /usr/bin/python3
ln -s /usr/local/python3.10/bin/pip3.10 /usr/bin/pip3

#验证
python3 --version
pip3 --version

基于Axios的自定义通用网络请求封装

封装代码如下：

/** axios 请求封装 */

// 引入axios
import axios from 'axios'

// baseURL选项，表示请求URL公共部分
const BASE_URL = "/dev-api"

// 创建axios实例
const instance = axios.create({
    baseURL: BASE_URL,
    // 超时时间
    timeout: 1000
});

// 请求拦截器
instance.interceptors.request.use(config => {
    // 在发送请求之前做些什么,包括请求配置
    config.headers['Authorization'] = config.isToken ? 'Bearer ' + localStorage.getItem('token') : null;
    config.headers['Content-Type'] = config.headers['Content-Type'] || 'application/json;charset=UTF-8'; // 默认请求头
    config.timeout = config.timeout || 1000; // 请求超时时间
    // 加载动画
    console.log("[loading]网络请求中...请稍后！");
    return config
}, error => {
    // 对请求错误做些什么
    console.log("网络请求错误！", error);
    return Promise.reject(error)
})

// 响应拦截器
instance.interceptors.response.use(response => {
    // 对响应数据做点什么
    console.log("response:", response);
    console.log("[关闭loading]网络请求成功！");
    return response
}, error => {
    // 对响应错误做点什么
    let { message } = error;
    if (message == "Network Error") {
        message = "后端接口连接异常";
    } else if (message.includes("timeout")) {
        message = "系统接口请求超时";
    } else if (message.includes("Request failed with status code")) {
        message = "系统接口" + message.substr(message.length - 3) + "异常";
    }
    console.log("[关闭loading]网络请求失败！", message);
    return Promise.reject(error)
})


/** 
 * 请求导出方法
 * @param {object} params  请求参数
 * @param {string} [params.headers] 请求头
 * @param {string} params.url 请求地址
 * @param {string} [params.method] 请求方法
 * @param {string} [params.data] 请求参数
 * @param {string} [params.params] 请求参数
 * @param {string} [params.headers] 请求头
 * @param {string} [params.timeout] 请求超时时间
 * @param {string} [params.isToken] 是否需要token
 * @return {Promise} 返回Promise对象
 * */
export const request = (params) => {
    return new Promise((resolve, reject) => {
        instance(params).then(res => {
            resolve(res.data)
        })
            .catch(err => {
                reject(err)
            })
    })
}

软件测试相关

制作合成大图片

在测试过程中，经常碰到一些需要添加图片的场景，然而想找到一些大小合适的照片又比较费时费力，这里记录一种使用Windows 命令行自带的copy命令扩充图片大小的方法。命令如下：

copy <原图片名称> /b <用于扩充的素材文件名称> <生成的新图片名称>

例如：原始的图片为mybase.jpg，用于扩充图片大小的文件为music.mp3，扩充后的图片命名为result.jpg，则命令如下：

#（copy 原图名称 /b + 需要扩充的文件名称 新图名称）
copy mybase.jpg /b + music.mp3 result.jpg

使用上述方法可以生成指定到大小的图片，轻轻松松测试图片大小边界值。

基于locust官方容器的启动脚本

docker run -d --name my-locust -p 8089:8089 locustio/locust -f /mnt/locust/locustfiles --class-picker
docker run -d --name my-locust -p 8089:8089 env-exam-test:v1.0

其它资源

类型	网址	说明
免费资源整合网站	https://free.hrsn.dev/
免费插图网站	https://undraw.co/illustratio https://3dicons.co/
渐变UI 背景/按钮网站	https://uigradients.com/#PinotNoi
VPN搭建教程	https://zybuluo.com/buzhimingyue/note/2568150
MP3音乐下载网站	https://www.myfreemp3.com.cn/
免费图标下载	https://icon-icons.com/zh/ https://remixicon.com/ https://vue-icons.com【Vue推荐】
Logo生成	https://logofa.st/
SSL免费证书	https://ohttps.com/	谷歌账号登陆
图床	https://imgchr.com/	QQ号登陆
PDF免费工具	https://tools.pdf24.org/zh/creator https://tools.pdf24.org/zh/
网站模板	https://www.mobanwang.com/
在线屏幕截图设备模型生成器	https://dimmy.club
pixabay免费图片素材网站	https://pixabay.com/zh/images/search/
视频解析下载网站	免费视频下载_哔哩哔哩B站视频下载_抖音无水印视频下载_YouTube油管视频下载-GreenVideo视频下载小天在线工具 - 免费短视频提取网站无水印解析保存网址
免费云数据库（MySql）	https://sqlpub.com	250xxxxxxx@qq.com账号登陆

文档技术支持：docsify
主题：vue主题