Notas del proceso completo de implementación de proyectos empresariales
Prefacio
Involucrando: servidor Linux, Docker, Jenkins, nginx, springoot, vue, mysql, redis, git,
Docker genera tipos de contenedores: MySql , Redis , Jenkins, Nginx, el contenedor donde se almacena el proyecto.
Nota: ! ! ! ! ! ! ! ! ! ! ! No almacene la base de datos en Docker, ya que el almacenamiento causará problemas durante el uso. ! ! ! ! ! ! ! ! ! !
- Al almacenar mysql, descubrí que la contraseña de la cuenta solo puede ser root y 123456. Habrá problemas con las otras contraseñas y aparecerá un error de inicio de sesión.
El proyecto comparte MySql y Redis. Utilice Jenkins para automatizar proyectos de implementación. Todos los proyectos front-end se almacenan en Nginx, con separación dinámica y estática y configuración de mapeo de subdominios. Los contenedores se comunican mediante una red personalizada.
1. Inicie sesión en el servidor Linux.
El autor utiliza Tencent Cloud 2-core 4G y utiliza el software Xshell para operar el servidor.
Preparación del paso de inicio de sesión: dirección IP pública del servidor , contraseña del servidor (si no ha cambiado la contraseña, puede encontrar la contraseña inicial en el buzón de Tencent Cloud), cuenta del servidor (el valor predeterminado es root)
1.1.Haga clic
1.2 Rellenar la IP pública
1.3. Complete el nombre de usuario
1.4. Complete la contraseña
1.5 Éxito
2. Instale Docker
Requerir
1. Docker requiere que la versión del kernel del sistema CentOS sea superior o igual a 3.10
2. Si se instaló anteriormente, primero debe eliminarlo:
sudo yum remove docker \
docker-client \
docker-client-latest \
docker-common \
docker-latest \
docker-latest-logrotate \
docker-logrotate \
docker-engine
1. Instalar el entorno básico.
sudo yum install -y yum-utils
2、设置镜像仓库（若阿里云镜像安装失败则使用官方）
阿里云镜像：
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
官方镜像：
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
3、安装前先更新 yum 包索引
yum makecache fast
4、安装最新版Docker docker-ce：社区版
sudo yum install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
5、启动
sudo systemctl start docker
（systemctl start docker.service #后台启动，systemctl enable docker #设置开机自动启动）
6、运行镜像判断是否安装成功
sudo docker run hello-world
注：可使用 docker version 查看版本信息
8、查看镜像
docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
hello-world latest 9c7a54a9a43c 4 months ago 13.3kB
注:这个hello-world是我刚才编写的，并非自带的
docker rm -f <containerid> 删除指定容器
docker ps # 查询容器
docker stop 容器名 # 停止容器
docker rmi 镜像名 # 删除镜像
docker ps -a # 查询所有容器状态
docker logs f28efc96ac5e # 日志
docker start -a ID # 启动容器容器ID/容器名称 -a参数是显示标准输出，“相当于”前台启动，不带-a参数相当于后台启动。
docker inspect 容器id # 查看容器详细信息
docker rm -f $(docker ps -aq)
# docker ps -aq：列出所有容器的 ID，包括正在运行和已停止的。
# docker rm -f：删除所有列出的容器。 -f 选项表示强制删除，即使容器正在运行也会被停止和删除。
# 请注意，这个命令会永久删除所有容器，包括你可能想要保留的容器。确保在运行之前，你已经备份了需要保留的容器中的数据或设置。
docker search image_name# 查询网络镜像
docker images# 查询本地镜像
docker exec -it 243c32535da7 /bin/bash # 进入容器
3. Red personalizada de Docker
Dado que los contenedores Docker no pueden comunicarse entre sí, la red se configura al crear el contenedor para facilitar el acceso entre los contenedores del proyecto. Si esto es necesario
3.1 Generar una red personalizada y probarla
Nota: El siguiente contenido es sólo para explicación, principio de visualización y método de uso. Seguirán pasos detallados.
命令：docker network ls
发现有如下网络：
bridge ：桥接 docker(默认)
none：不配置网络
host：和宿主机共享网络
(了解)container:容器网络联通(局限大，不建议)
# 我们直接启动命令默认末尾会带： --net bridge，即docker0，但是我们不使用这个，因为要使用到link关键字，这个关键字现在已经不使用了（弊端：无法通过域名进行访问）
docker run -d -P --name 容器名 --net bridge
1、创建自定义网络
命令：
docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
# 解释
# docker network create：创建 Docker 网络的命令。
# --driver bridge：指定网络驱动程序。在这里，使用的是默认的桥接（bridge）网络驱动程序，这是 Docker 默认的网络驱动程序，用于在容器之间创建私有网络。
# --subnet 192.168.0.0/16：指定网络的子网。在这个例子中，你指定了一个 IP 地址范围为 192.168.0.0 到 192.168.255.255 的子网。
# --gateway 192.168.0.1：指定网络的默认网关。在这里，你设置了默认网关为 192.168.0.1。
# mynet：这是你为网络指定的名称，你可以根据需要自定义网络名称。
2、查看网络是否创建成功命令
docker network inspect mynet
# config关键字下显示Subnet为 1921.68.0.0/16 Gateway下显示 192.168.0.1
3、创建并运行多个容器（用作测试容器间是否能够访问）
docker run -d -P --name 容器名1 --net mynet
docker run -d -P --name 容器名2 --net mynet
# -d：表示容器会以后台（detached）模式运行，也就是在后台运行容器，不会阻塞终端。
# -P：表示 Docker 会自动分配端口，将容器内部的端口映射到宿主机的随机端口上，使得容器的端口可以从外部访问。
# --name 容器名：为容器指定一个自定义的名称，你可以将 "容器名" 替换为你希望的名称。
# --net mynet：指定容器连接到名为 "mynet" 的 Docker 网络。这是一个自定义网络名称，你可以将其替换为你创建的网络的名称。
4、再次查看网络，观察容器是否被分配网络
docker network inspect mynet
5、使用IP进行容器访问，查看是否能够 Ping 通
docker exec -it 容器1 ping 192.168.0.3(这里的IP应该是容器2的IP地址)
6、使用名字进行 Ping 测试
docker exec -it 容器1 ping 容器2
# 注：上述两种方式均应成功
3.2 Conectividad entre redes
La red 192.168.0.0/16 creada anteriormente significa que todas las redes en 192.168.xx pueden acceder entre sí. Si otra red 172.18.xx quiere acceder a 192.168.xx en este momento, no será accesible.
1、将有172.18.x.x的网络与 mynet 相连
docker network connect mynet 容器名（即网络为 172.18.x.x 的容器）
2、再次查看网络情况
docker network inspect mynet
发现，实际上是将此容器加入到 mynet 网络中，即一个容器，两个IP。
3、测试是否能够 ping 通
docker exec -it 容器1 ping 容器2
4. Crea un espejo
Nota: Esto se puede omitir. Podemos especificar la imagen al crear el contenedor.
Necesitamos crear un total de las siguientes imágenes:
3、nginx ： docker pull nginx:latest
4、Jenkins: docker pull jenkins/jenkins:latest
5、查看镜像
docker images
输出：
REPOSITORY TAG IMAGE ID CREATED SIZE
jenkins/jenkins latest c9101035cede 13 hours ago 478MB
nginx latest f5a6b296b8a2 5 days ago 187MB
hello-world latest 9c7a54a9a43c 4 months ago 13.3kB
6、创建自定义网络
docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
5. Crea contenedores y bases de datos.
5.0 Montaje del contenedor
Nota: ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !
Cuando montamos el directorio, no lo coloquemos en inicio, incluso si desea colocarlo, necesita derechos de administrador o agregar sudo antes del comando, de lo contrario habrá un error inexplicable que no se puede iniciar.
- Al mismo tiempo, podemos elevar los derechos de las carpetas que deben montarse en el host. Si no eleva los derechos, es posible que la carpeta montada por el contenedor contenga algo pero no se pueda escribir en la carpeta host, lo que provocará que la carpeta host esté vacía, lo que a su vez hace que la carpeta en el contenedor también esté vacía.
- En segundo lugar, descubrí que incluso si elevo los permisos de la carpeta cuando uso nginx, todavía no hay ningún archivo después de la creación. Puede ser que haya cometido un error, etc., pero hay otra manera. Primero creamos la carpeta que debe montarse y luego crear el contenedor nginx. Nota No monte el archivo en este momento. Después de crear el contenedor, copie el contenido de la carpeta correspondiente en el contenedor a la carpeta correspondiente que debe montarse en el host. Luego elimine el contenedor, cree el contenedor nuevamente y escriba el montaje (nota: este método solo es adecuado para contenedores con el mismo contenido cada vez que se crean)
5.1 Instalar MySQL
Prefacio
¡El siguiente contenido es solo de referencia y no se ha utilizado en el uso real! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !
注：被 = 框起来的无需操作，这里只是作为演示，非要做会发现，必须要将密码设置为123456才能成功，且在挂载时不能事先创建文件夹，且容器的文件夹需要对照官网给的例子进行映射
================================================
1、创建Mysql容器并运行
docker run -d \
--name my-mysql-container \
-e MYSQL_ROOT_PASSWORD=your_root_password \
-e MYSQL_DATABASE=your_database_name \
-e MYSQL_USER=your_mysql_user \
-e MYSQL_PASSWORD=your_mysql_password \
-v /myDocker/mysql/conf:/etc/mysql/conf.d \
-v /myDocker/mysql/data:/var/lib/mysql \
-p 3306:3306 \
--net bridge \
mysql:5.7
# docker run：用于启动一个容器。
#-d：表示在后台运行容器。
#--name my-mysql-container：给容器一个自定义的名称，这里是 "my-mysql-container"，你可以根据需要更改它。
#-e MYSQL_ROOT_PASSWORD=your_root_password：设置 MySQL 的 root 用户密码。将 "your_root_password" 替换为你想要的密码。
#-e MYSQL_DATABASE=your_database_name：创建一个新的数据库并设置其名称。将 "your_database_name" 替换为你想要的数据库名称。
#-e MYSQL_USER=your_mysql_user 和 -e MYSQL_PASSWORD=your_mysql_password：可选的，用于创建一个新的 MySQL 用户并设置其密码。将 "your_mysql_user" 和 "your_mysql_password" 替换为你想要的用户名和密码。
#-v /path/to/your/mysql/data:/var/lib/mysql：这是挂载数据卷的部分。将 "/path/to/your/mysql/data" 替换为你本地系统上存储 MySQL 数据的目录路径。这将使 MySQL 数据在容器停止或删除时仍然保留在本地系统中。
#-p 3306:3306：将容器的 MySQL 端口（默认为 3306）映射到主机的相同端口，以便可以通过主机访问 MySQL 服务。
# --net bridge :指定网络
2、进入容器内部
docker exec -it mysql /bin/bash
docker exec -it mysql mysql -u root -p（直接登陆）
3、登陆
mysql -uroot -p123456
4、退出
exit （Ctrl+D）
========================================
Línea divisoria====
Lo anterior es solo para visualización y no para uso real. El siguiente es un tutorial real. Tenga en cuenta que Mysql no se implementa en un contenedor, sino que se usa directamente en el sistema Linux.
1、查找已安装的MySQL软件包和CentOS7下还需要查找是否存在mariadb包：
rpm -qa|grep mysql
rpm -qa|grep mariadb
若存在包，则删除、没用则不用执行。没有输出即无包
rpm -e --nodeps mysql-libs-5.1.73-1.el6.x86_64
rpm -e --nodeps mariadb-libs-5.5.56-2.el7.x86_64
2、提升权限，由于 MySQL 安装过程中，会通过 MySQL 用户在 /tmp 目录下新建 tmp_db 文件，所以需要给 /tmp 目录较大的权限
chmod -R 777 /tmp
3、检查依赖
rpm -qa|grep libaio
rpm -qa|grep net-tools
若不存在，则安装对应依赖
yum -y install libaio net-tools
4、安装
先进入opt目录
cd /opt
5、使用 wget下载并解压，在下载的过程中会显示进度条，包含 (下载完成百分比，已经下载的字节，当前下载速度，剩余下载时间)
wget http://dev.mysql.com/get/Downloads/MySQL-5.7/mysql-5.7.16-1.el7.x86_64.rpm-bundle.tar
tar -xvf mysql-5.7.16-1.el7.x86_64.rpm-bundle.tar
6、解压并安装
当执行上述命令且下载完成后，会自动出现一行解压命令，此时我们只需回车即可
安装：
解压后会有若干包，但我们只需使用其中一部分，安装如下包
rpm -ivh mysql-community-common-5.7.16-1.el7.x86_64.rpm
rpm -ivh mysql-community-libs-5.7.16-1.el7.x86_64.rpm
rpm -ivh mysql-community-client-5.7.16-1.el7.x86_64.rpm
rpm -ivh mysql-community-server-5.7.16-1.el7.x86_64.rpm
注意：1. 安装 server 会比较慢；
2. 如果前面第 1.3 步没检查好，在安装 mysql-community-server 会报错
7、初始化 Mysql
mysqld --initialize --user=mysql
8、查看并记住密码、“root@localhost:” 后面的就是初始化密码，要记下来，后面连接数据库会用到
cat /var/log/mysqld.log | tail -n 10
9、启动 MySQL 服务
systemctl start mysqld.service
10、查看是否自启动
systemctl list-unit-files|grep mysqld.service
若输出：mysqld.service enabled
则设置自启动
systemctl enable mysqld.sercice
11、登陆
mysql -uroot -p刚才记下的密码
出现：Welcome to the MySQL即为登陆成功，若出现错误，看密码是否正确，其中若密码中存在需要转义的字符需要使用英文双引号括起来，如：ssdd"("ddd
12、修改密码：因为初始密码为临时，会过期
ALTER USER 'root'@'localhost' IDENTIFIED BY '你的密码';
注：
1、复制时不要带 ; 因为带了会直接执行，不方便修改密码，当输入完成后需要添加上 ; 否则mysql以为你没有输入完。
2、密码太过简单会报错ERROR 1819 (HY000):
解决方法：
set global validate_password_policy=LOW; // 设置密码的验证强度等级为低(LOW)
set global validate_password_length=6; // 设置密码长度为6，最小为4
13、修改字符集
输入以下语句可以发现数据库和服务端的默认字符都是latin1，如果不修改容易出现乱码
show variables like 'character%';
+--------------------------+----------------------------+
| Variable_name | Value |
+--------------------------+----------------------------+
| character_set_client | utf8 |
| character_set_connection | utf8 |
| character_set_database | latin1 |
| character_set_filesystem | binary |
| character_set_results | utf8 |
| character_set_server | latin1 |
| character_set_system | utf8 |
| character_sets_dir | /usr/share/mysql/charsets/ |
+--------------------------+----------------------------+
解决方法：
输入 "vim /etc/my.cnf " 或用Xftp打开 "/etc/my.cnf " 文件进行编辑，在最后加上
character_set_server=utf8
init_connect=’SET NAMES utf8’
14、重启Mysql服务
systemctl restart mysqld
15、远程访问
输入以下语句查看MySQL的用户信息：
select host,user,authentication_string from mysql.user
输出：
+-----------+-----------+-------------------------------------------+
| host | user | authentication_string |
+-----------+-----------+-------------------------------------------+
| localhost | root | *514C5DC7D34822064704BE6926512A4A84BC1677 |
| localhost | mysql.sys | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE |
+-----------+-----------+-------------------------------------------+
#发现都是localhost，即本地访问
#host：表示连接类型
#%：表示所有远程通过 TCP方式的连接
#IP地址：如 (192.168.1.2,127.0.0.1) 通过制定ip地址进行的TCP方式的连接
#机器名：通过制定i网络中的机器名进行的TCP方式的连接
#::1：IPv6的本地ip地址 等同于IPv4的 127.0.0.1
#localhost：本地方式通过命令行方式的连接 ，比如mysql -u xxx -p 123xxx 方式的连接。
#user：表示用户名
#同一用户通过不同方式链接的权限是不一样的。
#authentication_string：密码
#所有密码串通过password (明文字符串)生成的密文字符串。加密算法为MYSQLSHA1，不可逆。MySQL 5.7的密码保存到#authentication_string字段中不再使用password字段(在5.5中使用)。
15.1、因此下面给出了用户授权、创建用户、删除用户和修改密码的命令。
用户授权命令(该命令执行授权时如果发现没有指定的用户，则会直接创建一个新用户来完成授权)：
grant 权限1,…权限n on 数据库名.表名 to 用户名@用户地址 identified by ‘密码’;
例如，授予通过网络方式登录的root用户，有对所有库、所有表的全部权限，密码设为”newpwd123”：
grant all privileges on *.* to root@'%' identified by 'newpwd123';
15.2、测试访问，就不讲了
注：记得将3306端口开放，如果是腾讯云就在安全组中添加规则，然后使用tcp:3306开放端口
16、补充知识
16.1、查看Mysql版本
mysqladmin -u root -p密码 –version
16.2、关闭Mysql服务
systemctl stop mysqld.service
16.3、查看mysql服务状态
systemctl status mysqld
16.4、连接数据库后修改数据库的字符集（其中mydb为数据库名）
alter table mytbl convert to character set 'utf8';
16.5、修改数据库表的字符集（其中mytbl为表名）
alter table mytbl convert to character set 'utf8';
16.6、创建Mysql用户
create user root identified by '123abc';
16.7、修改用户名
update mysql.user **set** user='li4' where user='wang5';
flush privileges; # 所有通过user表的修改，必须用该命令才能生效。
16.8、删除用户
drop user user@host;
16.9、修改当前用户的密码
set password = password('new_password')
16.10、修改某个用户的密码
update mysql.user set password=password('new_password') where user='name';
flush privileges; # 所有通过 user表的修改，必须用该命令才能生效。
Introducción a directorios relacionados.
5.2 Instalar redis
1、下载：版本可以选择其他
wget http://download.redis.io/releases/redis-5.0.7.tar.gz
2、解压、注意解压的目录，最好新建一个
cd /redis
tar -zxvf redis-5.0.7.tar.gz
3、安装gcc依赖环境
yum install gcc
4、编译与安装，这里可以在 cd /redis/redis-5.0.7
#切换到 redis-5.0.7 目录
cd /redis/redis-5.0.7
# 编译
make
# 安装
make install
默认安装路径为/usr/local/bin目录
5、后台启动
Redis默认是无法进行后台启动的，需要修改配置文件
cd /redis/redis-5.0.7
找到 redis.conf 文件并打开
在文件中查找：daemonize
发现其后跟着 no，我们将其修改为 yes，即：daemonize yes，然后保存
最后启动：
cd /usr/local/bin
redis-server /redis/redis-5.0.7/redis.conf
使用命令 ps -ef |grep redis 查看进程是否启动
输出为：
root 6370 1 0 16:56 ? 00:00:00 /usr/local/bin/redis-server *:6379
root 6384 2098 0 16:56 pts/0 00:00:00 grep --color=auto redis
或者使用客户端测试：输入命令
redis-cli
然后输入：ping，输出为 PONG 即可
6、开机自启动设置
6.1、新建目录
mkdir -p /etc/redis 用于存放redis的配置文件（一般将原来的配置文件复制一份出来）
mkdir -p /var/log/redis 用于存放redis的日志文件
mkdir -p /var/redis/6379 用于存放redis的持久化文件（6379表示redis实例的端口号）
6.2、将 redis.conf 配置文件（在/redis/redis-5.0.7下）复制到 /etc/redis 下并重命名为 6279.conf
6.3、修改6379.conf内容
- 注释掉bind 127.0.0.1
- daemonize no → daemonize yes
- logfile "/var/log/redis/6379.log" （注：查找logfile，并将其替换为此，下面的也一样）
- dir /var/redis/6379
- requirepass redis的密码 (注：这里可以设置密码，记得将注释取消)
6.4、将redis解压后的目录中的utils下面的redis_init_script文件复制到/etc/init.d下面，并重命名为redis_6379
6.5、修改redis_6379文件 （注：正常情况下无需改动，观察一下即可）
#这个类似一个定义，这边的定义需要和使用的redis启动的使用的配置文件名字保持一致（不要后缀名）
REDISPORT=6379
#使用的配置文件。这边就是去读取/etc/redis下面的“6379.conf“配置文件
CONF="/etc/redis/${REDISPORT}.conf"
就需要修改以上两个配置
6.6、将redis_6379服务设置为开机自启动
chkconfig redis_6379 on
6.7、重启，查看进程 ps -ef |grep redis
7、打开与关闭命令 ： 这里的 redis_6379 为/etc/init.d下面，重命名为redis_6379的文件名，可自行替换
# 打开redis命令:
service redis_6379 start
# 关闭redis命令:
service redis_6379 stop
8、设置密码后登陆
照成运行：
cd /usr/local/bin
redis-cli
发现可以，但是此时随意输入命令发现无法运行，此时我们有两种方法
- 已经运行 redis-cli 的情况下 ，我们输入 auth redis的密码
- 未运行 redis-cli 的情况下 ，我们输入 redis-cli -a redis的密码
返回 OK 则表示成功
6. Docker implementa Nginx
1、下载
docker pull nginx
2、创建挂载的文件夹，（但第一次创建容器不进行挂载，而是先创建容器然后将容器里需要挂载的文件复制到我们在Linux上真实的文件夹）
注：如果直接挂载，由于linux下的文件夹都为空会导致容器内也变成空
# 创建挂载目录
mkdir -p /home/nginx/conf
mkdir -p /home/nginx/log
mkdir -p /home/nginx/html
mkdir -p /home/nginx/ssl
- /home/nginx/conf
存放nginx的配置信息
- /home/nginx/log
存放日志信息
- /home/nginx/html
存放你的前端网页
- /home/nginx/ssl
如果想使用https，就需要这个文件夹，存放证书
# 提升权限
chmod 777 -R /home/nginx/conf
chmod 777 -R /home/nginx/log
chmod 777 -R /home/nginx/html
chmod 777 -R /home/nginx/ssl
3、创建容器并复制到宿主机
# 生成容器
docker run --name nginx -p 80:80 -d nginx
# 将容器nginx.conf文件复制到宿主机
docker cp nginx:/etc/nginx/nginx.conf /home/nginx/conf/nginx.conf
# 将容器conf.d文件夹下内容复制到宿主机
docker cp nginx:/etc/nginx/conf.d /home/nginx/conf/conf.d
# 将容器中的html文件夹复制到宿主机
docker cp nginx:/usr/share/nginx/html /home/nginx/
4、删除创建的容器
# 找到nginx对应的容器id
docker ps -a
# 关闭该容器
docker stop nginx
# 删除该容器
docker rm nginx
# 删除正在运行的nginx容器
docker rm -f nginx
5、再次创建容器，此时加入挂载文件夹以及自定义网络，加入自定义网络后容器间才能直接访问，这样前端才能访问后端
docker run \
-p 80:80 -p 443:443 \
--name nginx \
-v /home/nginx/conf/nginx.conf:/etc/nginx/nginx.conf \
-v /home/nginx/conf/conf.d:/etc/nginx/conf.d \
-v /home/nginx/log:/var/log/nginx \
-v /home/nginx/html:/usr/share/nginx/html \
-v /home/nginx/ssl:/etc/nginx/ssl \
--net mynet \
-d nginx:latest
# 注：这里创建时还映射了443端口，如果想通过https+域名访问，这个是必不可少的！！！！！！！！！
7、进入容器，更新nginx
//修改nginx配置，在不能重启的情况下，可以无需重新启动Docker容器即可重新加载新配置。Nginx可以hot-reload配置而不重新启动。
//查询nginx所在容器id：docker ps -a
docker ps -a
//测试nginx配置
docker exec 容器id nginx -t
//重新加载nginx配置
docker exec 容器id nginx -s reload
# 注：上述可能刷新失败，因为其要等到无连接后才能够刷新
6.1 Introducción al principio de los archivos de configuración.
La razón por la que hablo de esto es porque es un punto importante y difícil , ¡lo hablaré paso a paso!
Introducción al principio, puede omitirla, habrá información de configuración detallada más adelante.
En primer lugar, después de que activamos nginx y podemos acceder directamente a la página de nginx a través de la dirección IP, ¡significa que la implementación inicial fue exitosa!
Sin embargo, quedan varias preguntas:
1、 如果你的宿主机的端口号设置的不是80，那么在进行IP访问时一定要加上端口号才能访问。
像这样：`-p 80:80` ，设置时才不需要端口号直接使用IP访问。同时需要nginx开启端口监听
Mi requisito es que la IP pública sea única, pero habrá varios nombres de dominio apuntando a esta dirección y diferentes nombres de dominio representan diferentes proyectos de front-end. ¿Cómo lograr esto?
Antes de la implementación , debemos comprender el papel de ciertas cosas en el archivo de configuración. El siguiente es el contenido del archivo de configuración predeterminado (default.conf), que monté manualmente cuando lo creé /home/nginx/conf/conf.d. (Nota: he eliminado todo el código comentado para facilitar la explicación)
server {
listen 80; # IPV4类型的监控容器内的80端口，由于我宿主机也设置为80，两者结合才是无需使用端口号的原因
listen [::]:80; # IPV6类型的监听80端口
server_name localhost; # 重点，下面讲
# 当请求地址只有IP时，会走这里
location / {
root /usr/share/nginx/html; # 此用处为，会去容器下的这个目录寻找目标文件
index index.html index.htm; # 如果目标文件知道了，就不需要执行此处，若未找到，则在目标目录下下载是否有名为index.html index.htm 的文件，有则返回，无则404.由请求于只有IP，没有带其他目录所以一定会走这里。
}
# 当请求来了之后但是由于某些原因导致发生500等5开头的错误，会走这个
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root /usr/share/nginx/html;
}
}
Obviamente, esto es solo el resultado del servidor. El archivo de configuración completo es más que esto. Hay un archivo /home/nginx/conf/debajo nginx.confy los dos se combinan para formar un archivo de configuración completo.
2. Existe esta configuración en nuestro archivo de configuración inicial server_name localhost;. La dirección del archivo es la /home/nginx/conf/conf.dIP pública que usamos claramente, pero la configuración de archivo predeterminada aquí es la dirección local. Entonces, ¿por qué el acceso es exitoso?
Primero hablemos de todo el proceso de realizar una solicitud al contenedor nginx y reenviarla:
Primero, si usa la IP pública para el acceso, 43.126.94.119debido a que el valor de la asignación de puertos es 80 tanto para el host como para el contenedor nginx, y nginx ha configurado el puerto de escucha listen 80;, puede usar directamente la IP para el acceso sin agregar un número de puerto. .
Debido al mapeo de puertos, esta solicitud ingresará directamente a nginx. En este momento
serverLa función en el módulo server_nameobtendrá el valor del Host en el encabezado de la solicitud, que puede ser un nombre de dominio o una IP.
Si es IP
Se comparará con los valores serverde todos los módulos , si hay uno se reenviará al módulo correspondiente, si no hay ninguno se utilizará el módulo predeterminado.server_nameserverserver
¿Cuál es el módulo predeterminado? Es decir, si servereste parámetro está configurado en listen 80 default_server;, si no están todos configurados, se utilizará el primero por defecto.
Si es un nombre de dominio
Se realiza la misma coincidencia de nombre de dominio. Si no hay un módulo predeterminado, se utiliza el módulo predeterminado. Si no hay un módulo predeterminado, se utiliza el primer módulo.
Nota: Cuando utiliza el acceso IP, pero todo server``nombre_servidor nombre_servidor 值都为域名时，此时no es válido, se utilizará el módulo predeterminado o el primero.
server_nameTres casos de valor
localhost- nombre de dominio
- IP
依据上述原理，我们实现简易版的请求转发，有几种情况
情况一：
当我们使用公网IP访问，此时有两个 server模块
- 第一个模块的 server_name 值为：localhost，有一个 location / {}模块，即简写版
server_name localhost; # 重点，下面讲
location / {
}
- 第二个模块的 server_name 值为：43.137.94.117，有一个 location / {}模块，即简写版
server_name 43.137.94.117; # 重点，下面讲
location / {
}
若请求地址为 43.137.94.117 时 会走第 二 个模块 （因为模块二匹配成功）
情况二：
同样两模块，但此时location不同
- 第一个模块的 server_name 值为：localhost，有一个 location / {}模块，即简写版
server_name localhost; # 重点，下面讲
location / {
}
- 第二个模块的 server_name 值为：43.137.93.117，有一个 location / {}模块，即简写版
server_name 43.137.94.117; # 重点，下面讲
location ^~/gw {
}
若请求地址为 43.137.94.117 时 会走第 1 个模块 （因为模块都匹配不成功，且无默认模块，所以走第一个）
若请求地址为 43.137.94.117/gw 时 会走第 2 个模块 （因为 模块二 匹配成功，所以走第二个）
注：^~/gw 表示无论/gw前面是啥都进行匹配
En este punto del escrito, todavía no hay explicación sobre cómo acceder a diferentes proyectos cuando se accede a diferentes nombres de dominio pero apuntando a la misma IP.
Pero en realidad se ha dicho.
Utilice server_namela función y establezca su valor en un nombre de dominio diferente.
6.2 Configurar https y nombre de dominio para el acceso
1. Primero, tenemos que determinar si nginx puede implementar ssl, método de consulta
Ingrese al contenedor nginx, directorio cd /sbin, ejecute el comando nginx -V y verifique la salida. Si hay: docker exec -it nginx /bin/bash en la salida, significa que se puede implementar. Si no, necesita Para instalarlo primero. Puede aprender el método de instalación usted mismo. El contenedor que uso viene con nginx, por lo que no se requiere configuración adicional.
2. Obtenga el certificado SSL. Tencent Cloud tiene un certificado SSL gratuito. Después de solicitarlo, vaya a la interfaz Mi certificado, seleccione Descargar a la derecha, seleccione la descarga de nginx en Linux y obtendrá un paquete comprimido. Después de la descompresión, hay 4 archivos y luego copie los 4 archivos al directorio SSL que acabamos de crear en el servidor.
3. Configurar el archivo de configuración
En la sección Mi certificado de Tencent Cloud, hay una implementación a la derecha. Haga clic en ella para obtener un tutorial sobre cómo implementar https con nginx en Linux. Se puede comparar paso a paso.
Creamos /home/nginx/conf/conf.dun archivo de configuración en el directorio gw.confcon el siguiente contenido:
# 处理https请求的模块
server {
listen 443 ssl; #ssl，监听端口
server_name lvguidizi.com; # 域名
ssl_certificate /etc/nginx/ssl/lvguidizi.com_bundle.crt; # 容器路径下的ssl文件夹下的.crt文件
ssl_certificate_key /etc/nginx/ssl/lvguianzi.com.key;# 容器路径下的ssl文件夹下的.key文件
# 下面的 4 行按照腾讯云教程来，个个教程有可能有差异，所以哪里的服务器用哪里的教程
ssl_session_timeout 5m;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:HIGH:!aNULL:!MD5:!RC4:!DHE;
ssl_prefer_server_ciphers on;
# 我们做一个跳转，当通过域名访问时，将其跳转到 https://域名/gw 下，当然，你也可以不这样做
location / {
# 这意味着任何访问网站根目录的请求都会被重定向到 https://lvguidianzi.com/gw 这个 URL。
rewrite ^/(.*) https://lvguidizi.com/gw;
}
# ^~/gw：表示无论/gw前面是啥只要后面以这个结尾都会进入这里，
# 作用，会去你root设置的文件夹下寻找你location设置的/gw文件夹，并在文件夹下寻找你index设置的 indez.html文件
location ^~/gw {
# 这个块处理以 /gw 开头的 URL 路径的请求。它使用 try_files 指令尝试寻找匹配的文件，如果找不到文件，则会重定向到 /gw/index.html; 页面。
# 这个块还设置了 root 和 index 指令，以指定根目录和默认索引文件。
try_files $uri $uri/ /gw/index.html;
root /usr/share/nginx/html;
index index.html;
}
# 这个用来做动静分离，相当于此路径下存放图片和一些其他文件
# 同样，他会去 root+location的路径下找，相当于/usr/share/nginx/html/file/
location /file/ {
root /usr/share/nginx/html/;
autoindex on; # 列出访问目录
}
#location ^~/openApi/ {
# proxy_pass http://172.16.0.12:9999/openApi;
# proxy_set_header Host $host; # 这个指令设置了请求头中的 "Host" 字段，将其值设置为客户端请求中的 "Host" 值。这是为了确保后端服务器能够正确识别客户端请求的主机名。
# proxy_set_header X-Real-IP $remote_addr; # 这个指令设置了一个自定义请求头 "X-Real-IP"，将其值设置为客户端请求的真实 IP 地址。这可以帮助后端服务器获取客户端的真实 IP 地址。
# proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; # 这个指令设置了另一个自定义请求头 "X-Forwarded-For"，将其值设置为 $proxy_add_x_forwarded_for，它包含了所有中间代理服务器的 IP 地址。这有助于追踪请求经过的代理服务器链。
# # 这两个指令用于配置 Nginx 内部的请求头哈希表的大小。这些配置项通常不需要手动设置，除非您在配置文件中有特殊的需求。
# proxy_headers_hash_max_size 512;
# proxy_headers_hash_bucket_size 64;
#}
#location ^~/api/ {
# proxy_pass http://172.17.0.1:8081/;
# proxy_set_header Host $host;
# proxy_set_header X-Real-IP $remote_addr;
# proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
# proxy_headers_hash_max_size 512;
# proxy_headers_hash_bucket_size 64;
#}
error_page 404 /404.html;
# 这个指令指定了处理状态码 497 的方式。状态码 497 表示客户端应该将请求转发到另一个地址，通常是由于客户端请求协议与服务器配置的协议不匹配。在这里，当发生状态码 497 时，
# Nginx 会将请求重定向到 https://$host$uri?$args;，这意味着它将使用相同的主机名和请求 URI 重新发送请求，但使用 HTTPS 协议。
error_page 497 https://$host$uri?$args;
error_page 500 501 502 503 504 /50x.html;
# 这个 location 块定义了 /50x.html 页面的位置。它告诉 Nginx 在根目录的 html 子目录下寻找 50x.html 文件。这是用于定义错误页面的位置。
location = /50x.html {
root html;
}
}
# 处理http请求的模块
server {
listen 80;
listen [::]:80;
server_name lvguidizi.com;
location / {
# 当我们以http+域名方式进行访问时，会走到这里，然后会将http转换为https重新请求，就会回到上面的模块了
return 301 https://$host$request_uri;
}
}
# 处理公网IP的请求
server {
listen 80;
listen [::]:80;
server_name 43.136.9.118;
location / {
# 如果是公网IP访问，如果没有进行出来就会走默认模块，也就是nginx自动创建的第一个配置文件，也就是我们部署好nginx时访问网页会出现的 welcome to nginx。所以我们也需要跳转，
return 301 https://lvguidizi.com/gw;
}
}
Después de configurar el archivo de configuración, necesitamos crear una nueva carpeta gw en la carpeta html y crear un archivo index.html. Luego podemos probar el acceso a través del nombre de dominio https://. Al mismo tiempo, también podemos empaquetar el vue Si el proyecto se coloca en la carpeta gw, se accederá automáticamente a él.
Nota: Si cree que todo está configurado pero no puede acceder a él, puede deberse a las siguientes razones:
1. El puerto 443 de su servidor no está abierto (Tencent Cloud es un grupo de seguridad abierto) o el puerto 443 de su contenedor nginx no está asignado (ambos deben estar presentes).
2. Su certificado SSL no está vinculado al nombre de dominio.
3. Su nombre de dominio no está vinculado a la dirección IP pública de su servidor.
4. Tu nombre de dominio no está registrado
5. Una vez completado el archivo de configuración, es necesario actualizar nginx.
6. El nombre del certificado SSL o la configuración de la ruta en el archivo de configuración son incorrectos. Recuerde que es la ruta del contenedor.
7. La ruta de acceso compuesta por la ubicación y los módulos raíz en su archivo de configuración es diferente de su ruta de solicitud real.
6.3 Configurar el mismo nombre de dominio para implementar múltiples proyectos vue
Supongamos que hay dos proyectos vue a y b.
1. Realice la siguiente configuración en el archivo de enrutamiento del proyecto a (es decir, el archivo donde Vue almacena los saltos de enrutamiento):
// 如果你的路由配置文件中没有这个，就新添一个
export default new VueRouter({
base:'/a/', // 相当于在每一个路由跳转的路径前面加一个/a/路径
}
2. También agregue la configuración anterior al proyecto b, pero base:'/a/'cámbiela abase:'/b/'
3. Si es vue2, configure lo siguiente configen la carpeta index.js(recuerde cambiar el proyecto b de acuerdo con las reglas):
...
build: {
assetsPublicPath: '/a/', // 将这个变量设置为你在路由上设置的路径，记得一致，这个是配置公共资源访问路径的选项，因为你的vue项目不在根目录下了，所以这里也要变
}
...
4. Modificar el archivo de configuración de nginx
# 增加一个 location
location ^~/a {
try_files $uri $uri/ /a/index.html;
root /usr/share/nginx/html;
index index.html;
}
location ^~/b {
try_files $uri $uri/ /b/index.html;
root /usr/share/nginx/html;
index index.html;
}
5. El directorio html de nginx es el directorio raíz donde se almacena el proyecto vue. Cree dos carpetas a y by almacene el proyecto vue en la carpeta, luego actualice el archivo de configuración.
6. Adicional: debido a que el proyecto vue accederá al backend, si es springboot, debemos agregar un proxy a nginx en este momento. (El interrogador no sabe si es necesario, pero usa el front-end de Ruoyi. Esto es necesario para acceder al backend. En circunstancias normales, se puede acceder ingresando directamente la dirección del backend, pero después de agregar el front-end de Ruoyi -end No puedes acceder al backend a través del frontend)
# 这个路径 /prod-api/ 是要与前端vue项目里面的一致
location ^~/prod-api/ {
proxy_pass http://172.16.0.12:9999/; # 你的公网IP或者内网IP加上后端的端口号
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_headers_hash_max_size 512;
proxy_headers_hash_bucket_size 64;
}
Hay un archivo en el front-end Ruoyi .env.productioncon el siguiente código:
# 页面标题
VUE_APP_TITLE = 若依管理系统
# 生产环境配置
ENV = 'production'
# 若依管理系统/生产环境
VUE_APP_BASE_API = '/prod-api' # 这个就是要与nginx里面一致的东西了
7. Docker implementa Jenkins
! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ¡Puntos pesados y difíciles! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !
Si simplemente sigues los tutoriales en línea, poco a poco te irás confundiendo: incluso hay 100 tutoriales con 100 métodos. . .
Primero, hablemos de por qué necesitamos usar jenkins en Docker.
Por conveniencia, hay muchas configuraciones de Jenkins. Los principiantes pueden cometer errores accidentalmente. Si están en la máquina host en este momento, es difícil borrarlos con un clic. Pero Docker es diferente. Eliminar el contenedor y luego crearlo es otra cosa buena..
En segundo lugar, de forma predeterminada en el siguiente tutorial, ya instaló Docker, ¡así que comencemos!
前言：自动化部署流程
首先，我们创建运行jenkins容器，然后登陆jenkins，设置好gitee，jdk，maven，ssh等等。记得在我们的项目的根目录(如果是多模块项目，就在启动模块的根目录)下创建Dockerfile文件，然后就是创建maven项目，在项目设置里，设置好需要git的文件路径，然后设置需要打成jar包的模块。然后设置shell语句。
- gitee：存放我们的项目代码，
- jdk，maven：打成jar包需要的环境，jenkins自带jdk，但如果是最新的jenkins是jdk11，所以要么我们创建容器时控制为jdk8的版本要么在jenkins的系统设置里面手动修改(此修改需要在宿主机安装jdk，比较麻烦)，maven是没有自带的，需要我们手动安装或者自动安装，没啥区别。
- ssh ：推送，相当于将我们创建好的jar推送到指定服务器上运行，因为是在容器里面生成的jar包，
- Dockerfile文件：用来创建我们项目的docker镜像，只有创建镜像才能依据镜像创建容器，才能运行jar包
1、在jenkins中我们需要挂载某些文件，但是如果你挂载在宿主机的文件夹没用权限，那么g了，当你挂载创建完成后，会发现文件夹空无一物。所以我们需要在宿主机下先创建文件夹。然后提升文件夹权限。
mkdir -p /common/jenkins_home # 创建文件
chmod 777 -R /common/jenkins_home # 提升权限
chmod 777 -R /var/run/docker.sock # 下面两个权限提升是以防万一，这两个文件夹作用等下说
chmod 777 -R /usr/bin/docker
2、让Jenkins 容器里面能够使用宿主机的 docker 命令
在自动化部署时，我们在执行容器，镜像创建时是在jenkins里面的，但是正常情况下jenkins容器里面用不了容器外的docker命令，所以我们这里将docker命令需要的东西进行映射一下，也就是挂载。所以先将用到的文件夹提升权限，怕需要。需要挂载的文件夹有这两个：
-v /var/run/docker.sock:/var/run/docker.sock \
-v /usr/bin/docker:/usr/bin/docker \
3、创建并运行jenkins容器
docker run -d -p 8080:8080 -p 50000:50000 \
--net mynet --restart=on-failure \
-v /common/jenkins_home:/var/jenkins_home \
-v /var/run/docker.sock:/var/run/docker.sock \
-v /usr/bin/docker:/usr/bin/docker \
--name jenkins jenkins/jenkins:lts-jdk8
# 解释：
-p 8080:8080：
端口8080用于Jenkins的Web界面
-p 50000:50000
用于Jenkins的Slave节点通信。Slave节点是用于执行构建作业的工作节点。
--net mynet:这个是我自己创建的自定义网络，容器间通信使用
--restart=on-failure: 这部分指定了容器在失败时应该自动重启。如果Jenkins容器崩溃或失败，Docker将尝试重新启动它。
-v /common/jenkins_home:/var/jenkins_home \：就是查看jenkins初始密码和一些其他文件，所以需要挂载
-v /var/run/docker.sock:/var/run/docker.sock \
-v /usr/bin/docker:/usr/bin/docker \：这两个是运行docker命令需要的
--name jenkins：指定容器名字
jenkins/jenkins:lts-jdk8：指定自带jdk版本为8
运行 docker ps 命令，如果在运行的容器列表找到了jenkins表示创建并运行成功！
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
7ad88fe4f57b jenkins/jenkins:lts-jdk8 "/usr/bin/tini -- /u…" 27 hours ago Up 27 hours 0.0.0.0:8080->8080/tcp, :::8080->8080/tcp, 0.0.0.0:50000->50000/tcp, :::50000->50000/tcp jenkins
4、通过服务器加端口访问jenkins：如119.168.1.3:8080，服务器就是你自己的公网IP，端口号是创建时设置的。
5、等它加载会，会让你输入密码，这个秘密存在的地址会在网页上显示，可以通过路径打开文件获取
6、密码输入完后会有两个选择，安装推荐的插件和选择插件来安装。我们选择安装推荐的插件，然后就是等待下载完成
7、会显示让你创建第一个用户，一次填写好并记下来，后面会用到。
Bien, ahora necesito imágenes y texto:
7.8. Primero descargue el complemento. Después de iniciar sesión, seleccione la opción Administrar Jenkins a la izquierda, que tiene un pequeño engranaje, que es equivalente a la configuración. Luego deslícese hacia abajo y seleccione Administrar complementos.
7.9. Descargue los siguientes tres complementos respectivamente, Maven Integration, gitee y Publish Over SSH. Las abreviaturas se encuentran en el cuadro de entrada a continuación, que también se puede encontrar. En la segunda imagen, después de encontrarlo, márquelo y haga clic en Instalar. sin reiniciar.
7.10 Haga clic en Configuración global
Nota: Recuerde guardar el token privado. Después de obtenerlo, regrese a Jenkins e ingrese el token. No es necesario completar el ID y la descripción a continuación. Simplemente guárdelo. Luego habrá una opción como la mía. Seleccione directamente.
7.11、SSH
Mantener el resto por defecto
Luego regrese a la configuración y esta vez haga clic en el del medio en la primera fila.
7.12 No se preocupe por maven y jdk al comienzo de la Configuración global de la herramienta. Encontramos maven a continuación.
7.13 Crear proyecto maven
Aquí comenzamos oficialmente a realizar una implementación automatizada, antes de realizarla, primero debemos preparar algo.
1. Cree un archivo para crear una imagen de proyecto de código en el directorio raíz del proyecto de código o en el directorio raíz del módulo de inicio de un proyecto de varios módulos: Dockerfile
Nota: Recuerda subir este archivo a gitee
FROM java:openjdk-8u111
VOLUME /tmp
ADD target/ruoyi-admin.jar ruoyi-admin.jar
EXPOSE 9999
ENV TZ=Asia/Shanghai
ENV JAVA_OPTS="-Xms256m -Xmx1024m -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=512m"
ENTRYPOINT ["java","-jar", "$JAVA_OPTS","/ruoyi-admin.jar"]
- FROM java:openjdk-8u111 ：
基础镜像是 java:openjdk-8u111，表示基于 OpenJDK 8u111 版本的 Java 运行时环境。
- VOLUME /tmp
在容器内创建一个临时卷，通常用于存储临时文件或持久化数据。
- ADD target/ruoyi-admin.jar ruoyi-admin.jar
将宿主机上的 target/ruoyi-admin.jar 文件复制到容器内，并命名为 ruoyi-admin.jar。因为jar包在此文件运行前就创建好了，jar创建的设置在下面会讲到。
为什么地址是 target/ruoyi-admin.jar？
因为在下面的设置及其运行结果看，在执行这几行代码前，整个项目已经处于workspace/ruoyi-admin/下了。workspace是jobs/目录下的一个文件夹。 jobs 是jenkins专门用来存放创建好的maven项目。里面包含项目相关的东西
- EXPOSE 9999
就是你代码项目启动需要的端口号
- ENV TZ=Asia/Shanghai
时区
- ENV JAVA_OPTS="-Xms256m -Xmx1024m -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=512m"
初始堆内存大小，最大堆内存大小，元空间初始大小，元空间最大，若超出则垃圾回收
- ENTRYPOINT ["java","-jar", "$JAVA_OPTS","/ruoyi-admin.jar"]
定义容器启动时要执行的命令。它启动了一个 Java 进程，运行 ruoyi-admin.jar
2. Crea oficialmente un proyecto maven.
Haga clic en Agregar para configurar el nombre de usuario y la contraseña.
Orden:
clean install -pl ruoyi-admin -am -amd
# 一般写上面就行，下面是补充
clean package -pl ruoyi-admin -am -amd -P test -Dmaven.test.skip=true
clean package 清除打包
-pl ruoyi-admin -am -amd 指定项目下的子模块
ruoyi-admin 是子模块的项目名
-P test 指定构建环境，项目配置文件的名字
-Dmaven.test.skip=true 跳过maven测试
A continuación se indica qué se debe ejecutar cuando el jdk y maven del proyecto estén listos y también se cree el jar. En este momento, es necesario borrar las cosas antiguas (si las hay) y luego comenzar a ejecutar el archivo Dockerfile para crear la imagen. Y luego pase La imagen crea el contenedor, luego lo ejecuta, luego verifica si el contenedor se está ejecutando y luego se implementa.
El código de shell aquí es :
docker stop ruoyi-admin || true
docker rm ruoyi-admin || true
docker rmi ruoyi-admin || true
docker build -t ruoyi-admin ruoyi-admin/
mkdir -p common/logs/ruoyi-admin
chmod 777 -R common/logs/ruoyi-admin
docker run -d -p 9999:9999 -v /common/logs/ruoyi-admin:/home/ruoyi/logs --net mynet --name ruoyi-admin ruoyi-admin
# 解释：
- docker stop ruoyi-admin || true
如果有旧容器就停止，没有就返回true，继续
- docker rm ruoyi-admin || true
docker rmi ruoyi-admin || true
同上，有就删除容器与镜像
- mkdir -p common/logs/ruoyi-admin
chmod 777 -R common/logs/ruoyi-admin
创建文件夹和提升权限
- docker build -t ruoyi-admin ruoyi-admin/
这个命令从位于ruoyi-admin/目录中的Dockerfile构建一个名为ruoyi-admin的Docker镜像，并使用-t选项为镜像指定名字。
以workspace文件夹为始
- docker run -d -p 9999:9999 -v common/logs/ruoyi-admin:/var/logs --link redis:redis --link mysql:mysql --net mynet --name ruoyi-admin ruoyi-admin
-d：以后台模式运行容器。
-p 9999:9999：将主机的9999端口映射到容器的9999端口。
-v common/logs/ruoyi-admin:/var/logs：将主机上的common/logs/ruoyi-admin目录映射到容器的/home/ruoyi/logs目录，用于日志持久化。我使用的若依，它已经帮我配置好了日志文件，所以可以直接使用，如果是其他的项目需要自己在springboot项目里面创建logback.xml 去进行设置，具体百度
--link redis:redis --link mysql:mysql：将容器连接到名为redis和mysql的其他容器。
--net mynet：将容器连接到名为mynet的自定义网络。
--name ruoyi-admin：为容器指定名称为ruoyi-admin。
ruoyi-admin：指定要运行的Docker镜像。
===============================
如果想将此代码放入一个sh文件，由于win和linux差别，win创建*.sh文件是无法直接在linux下运行，需要将文件通过
chomd +x ./q.sh
命令，将sh变为可执行文件。
En este punto, todas las configuraciones se completan y luego se guardan. Regrese a la página de inicio y comience a construir el proyecto. La compilación inicial descargará maven y jdk, por lo que será lenta. Luego puede verificar el registro si la compilación falla y ver qué paso salió mal.
8. Varios
1. Cómo importar archivos de fuentes
- Utilice la separación dinámica y estática de nginx, coloque el archivo de fuente en él, luego haga referencia a su ruta en el proyecto y luego modifíquelo en el archivo de configuración de nginx para la separación dinámica y estática, agregue un elemento
location:add_header Access-Control-Allow-Origin *;# 解决字体文件跨域问题
location /file/ {
root /usr/share/nginx/html/;
autoindex on; # 列出访问目录
add_header Access-Control-Allow-Origin *;# 解决字体文件跨域问题
}
- Cuando se almacena localmente, se descubre que se puede acceder a él, pero la página web mostrará que falló la carga del archivo de fuente.
.gitignoreAgregue el archivo*.ttf binary, es decir, el sufijo de su archivo de fuente, y estará bien, pero No entiendo por qué puede...
Nota: De hecho, esto puede tener éxito, pero hay un problema: los archivos de fuentes son relativamente grandes, desde unos pocos metros hasta más de 10 metros. Para el acceso a la página web, la carga es muy lenta y afecta la experiencia del usuario, por lo que necesitamos para optimizar los archivos de fuentes y convertirlos. Elimine las fuentes que no se utilizan en nuestro proyecto y regenere los archivos de fuentes.
Aquí se utiliza la palabra araña.
Independientemente de cuál de los métodos anteriores se utilice, el paquete de fuentes debe simplificarse y el principio operativo de Zizi es:
Cree un nuevo archivo index.html, importe nuestras fuentes personalizadas y algo de texto en el archivo, y luego use Word Spider para generar una versión simplificada del archivo de fuente. La cantidad de fuentes en este archivo depende de lo que escribió en el archivo html. .Número de personajes diferentes.
Utilice la palabra araña :
1. Asegúrese de que la versión de su nodo sea aproximadamente 16. Existen ciertos requisitos para la versión de npm requerida para usar Zi Spider, que parece ser 6.9.0 o superior. Aquí actualizamos npm instalando nodejs.
2. Abra cmd con derechos de administrador e ingrese el comando
npm install font-spider -g
Si lo guarda, verifique ambos aspectos: si fue iniciado por el administrador y si la versión de npm es superior a 6.9.0.
3. Instale variables de entorno para Zizi. Generalmente, E:\nodejs\node_cachehay un archivo en el directorio debajo del directorio de instalación de nodejs font-spider.cmd, encontramos esta ruta, abrimos la configuración de variables de entorno, seleccionamos pathCrear una nueva en la configuración de las variables de entorno del sistema y seleccionamos la ruta E:\nodejs\node_cache. Luego confirma.
4. Podemos colocar el archivo de fuente personalizado en una carpeta y luego crear un archivo index.html en la carpeta, suponiendo que el archivo de fuente se llama a.ttf. Luego escriba el siguiente contenido en el archivo index.html:
<!DOCTYPE html>
<html lang="en">
<style>
@font-face {
font-family: 'a';
src: url("a.ttf") format('truetype');
font-weight: normal;
font-style: normal;
}
</style>
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<div>
这里写出所有你想要的文字，字蛛会自动扫描这个文件里面的文字，然后基于你给的文字生成一个字体文件
</div>
</body>
</html>
<style>
div{
font-family: "a";
}
</style>
Luego use derechos de administrador, abra cmd y cambie de directorio a esta carpeta. Es decir, la carpeta donde existen el archivo de fuente a y el archivo index.html.
Luego ejecute el comando:
font-spider index.html
Después de ejecutarlo por un tiempo, encontrará que se genera una carpeta debajo de la carpeta .font-spidery su archivo de fuente original a está almacenado en esta carpeta. El nuevo archivo de fuente generado está al mismo nivel que index.html y también se llama a.ttf, es decir, el nuevo archivo sobrescribe el archivo antiguo. Luego podemos usar este archivo y encontraremos que el tamaño del archivo se vuelve mucho más pequeño.