前后端项目部署辅导

转x33g5p2x  于2022-02-12 转载在 其他  
字(12.8k)|赞(0)|评价(0)|浏览(533)

Linux常用命令：

  1. lsof -i:8090 //查看端口是否被占用
  2. kill -s 9 pid //杀死进程
  3. jps //查看启动的java应用进程
  4. scp -P 22（服务器端口号） smpe-system-1.0.0-RELEASE.jar  root@ip地址:/data/nginx/www/cloudsafe/cloudsafe_server（服务器中文件夹的绝对路径） 
  5. //远程复制，将本地的xx.jar， 上传到服务器的xxxx/cloudsafe_server文件夹，注：（）为解释，执行时自行删除，此命令是在jar的所在目录下执行的。
  7. docker exec -it a4f598cc4268（容器id） mysqldump -uroot -p*********（数据库密码） --opt research_keyuan（数据库名称） > /root/mysql_file_backup/mysqlbakup_research_keyuan.sql  （用来保存sql文件的路径及文件名）
  8. //此命令用来备份docker中的mysql数据库sql文件
  10. docker exec -i a4f598cc4268（容器id） mysql -uroot -p*****（数据库密码） research_keyuan < /root/mysql_file_backup/xxxx.sql
  11. //此命令是用来将sql文件导入到docker中的mysql容器的mysql的指定数据库

环境准备

下面的环境只适用于Centos 7.x

Docker

添加yum源

  1. yum update //检查更新
  1. yum install epel-release -y //添加yum的软件仓库

安装docker

  1. yum install docker-io -y

运行docker

  1. systemctl start docker

检查安装结果

  1. docker info

停止docker

  1. systemctl stop docker

重启docker

  1. systemctl restart docker

docker的常用命令

  1. docker pull xxx //拉取应用镜,如拉取nginx镜像：docker pull nginx
  2. docker images //查看已有镜像
  3. docker rmi 镜像id //删除镜像
  4. docker ps //查看启动的容器
  5. docker ps -a //查看容器，包含了未启动的容器
  6. docker stop 容器id //停止容器
  7. docker rm 容器id //删除容器，需要停止容器
  8. docker exec -it 容器id/名称 bash //进入容器内部
  9. docker inspect 容器id/名称 | grep Mounts -A 20 //查看容器与服务器的映射目录
  10. docker inspect 容器id/名称 | grep IPAddress //查看容器的ip地址

下面需要安装一些公共服务如：mysql ,redis, nginx

两种方案：在docker中安装，在服务器中直接安装，两种方式都可，建议选择一种，仁者见仁吧，根据方式不一样，后端的部署也会有些细微变动。

一、Docker安装各种服务
Docker 安装mysql

安装

  1. docker pull mysql //后面不加版本号，默认最高版本

启动

  1. docker run -itd --name mysql-test -p 3306:3307 -e MYSQL_ROOT_PASSWORD=123456 mysql

  • 参数说明：

  • -p 3306:3307 ：映射容器的 3307 端口到服务器的 3306 端口，外部主机可以直接通过 宿主机ip:3306 访问到 MySQL 的服务。

  • MYSQL_ROOT_PASSWORD=123456：设置 MySQL 服务 root 用户的密码。

  • 注：启动后，如果需要远程访问，需要开启服务器的相应端口号

检查

  1. docker ps //查看是否安装成功
Docker 安装Redis

安装

  1. docker pull redis

启动

  1. docker run --name redis -p 6379:6379 -d --restart=always redis redis-server --appendonly yes --requirepass "这是密码"

  • 参数说明

  • -p 6379:6379 端口映射：前表示服务器的端口，：后表示容器的端口。

  • –name myredis 指定该容器名称，查看和进行操作都比较方便。

  • -d redis 表示后台启动redis

  • appendonly yes 开启redis 持久化

Docker 安装nginx

由于内容有点多，都记录到此篇博客中基于Docker使用Nginx

二、服务器安装各种服务

服务器中，我是采用yum源来安装各种服务，这种方式比较简单（强烈推荐）

yum安装Mysql

1、检查系统是否安装有mysql

  1. yum list installed mysql*
  2. rpm -qa | grep mysql*

2、安装客户端

  1. yum install mysql

3、安装服务端

  1. yum install mysql-server
  2. 注：可能提示为安装失败
  3. 原因：CentOS7自带有MariaDB而不是MySQL，MariaDB和MySQL一样也是开元的数据库
  4. 解决方案：如果必须要安装MySQL，首先必须添加mysql社区repo通过输入命令：
  5. sudo rpm -Uvh http://dev.mysql.com/get/mysql-community-release-el7-5.noarch.rpm
  6. //执行后， 继续执行
  7. yum install mysql-server

4、执行

  1. yum install mysql-devel

5、配置数据库

vim /etc/my.cnf

在配置文件中加入默认字符集：

default-character-set=uft-8

6、启动或关闭

  1. [root@localhost ~]#service mysqld start      --启动mysql[root@localhost ~]#service mysqld stop       --关闭mysql
  2. [root@localhost ~]#lsof -i:3306              --数据库端口是否开启

7、设置开机启动mysql服务

  1. chkconfig --add mysqld

8、创建root管理员

  1. mysqladmin -u root password 密码

9、进入mysql设置远程访问

  1. //依次执行
  2. mysql -u root -p
  3. use mysql;
  4. UPDATE user SET `Host` = '%' WHERE `User` = 'root' LIMIT 1;

10、在服务器的控制台中防火墙，将数据库端口打开（安全组规则中添加3306端口）

yum安装redis

1、yum install redis

2、yum isntall epel-release

3、启动服务

systemctl start redis

4、查看状态

systemctl status redis

5、停止服务

systemctl stop redis

6、重启服务

systemctl restart redis

7、查看redis进程

ps -ef | grep redis

8、设置开机自启动

systemctl enable redis

9、设置远程连接

进入配置文件

vi /etc/redis.conf

注释bind 127.0.0.1

设置protected-mode no

修改密码为111111

10、保存并退出编辑重启redis

systemctl restart redis

11、在服务器的控制台的安全组规则，开放redis端口号6379

yum 安装git

1、安装

  1. yum install git

2、配置

  1. //设置用户名称和登录邮箱
  2. git config --global user.name '用户名'
  3. git config --global user.email '邮箱'

3、生成密钥，方便拉取远程仓库代码

建议在服务器根目录执行，**cd / ** 可以切换到根目录

  1. ssh-keygen -t rsa -C '登录邮箱'

执行之后，不建议输入密码，直接一直Enter跳过

完成后，一般会在**/root/.ssh/文件夹中生成两个文件，大家id-rsa.pub文件的内容，全部复制，找到github个人账户设置，在ssh key 中的菜单中新增ssh key,将内容粘贴进去即可。

配置Nginx代理

此方案基于Docker容器中的Nginx

1、查看Nginx挂载目录

  1. docker inspect nginx | grep Mounts -A 40

Source对应服务器的文件夹，Destination对应nginx_config文件夹

注：如果你看的我博客进行配置的，会看到有五个挂载目录，有两个目录，很重要，其他是配置文件和日志的。

2、在conf.d文件夹加入项目的nginx配置

文件名：xxx.conf（xxx自己随意命名）

  1. upstream myserver{
  2.     #172.17.0.6是项目所在容器的ip地址，8000为项目的端口，请根据实际情况修改；如果项目是在服务器裸奔的，可以直接用127.0.0.1:端口
  3.     server 172.17.0.6:8000;
  4. }
  6. server{
  7.     #监听的端口
  8.     listen 80;
  9.     #域名，根据实际情况修改，（没域名，可以直接写成ip地址）
  10.     server_name kygl.ruanzhuinfo.com;
  11.     client_max_body_size 500m;
  13.     access_log /var/log/nginx/host.access.log main;
  14. 	#后台
  15.     location /admin {
  16.         #root 后面路径在服务器的路径为：/data/nginx/www/kygl_v2/dist_web
  17.         #因为nginx需要代替(代理)你访问文件，nginx是在一个docker容器中和服务器不是在一个环境下，所以需要路径改成在容器中的路径，dist_web为前端的打包的文件夹，要保证dist_web中有index.html
  18.         root   /nginx_config/www/kygl_v2/dist_web/;
  19.         try_files $uri $uri/ /index.html?s=$uri&$args;
  20.         index index.html index.htm index.php;
  21.     }
  22.     #前台，如果有前台，可以配置，同上，因为root只能存在一个，所以下面用的alias来配置另一个虚拟目录
  23.     #location /front {
  24.     #   alias   /nginx_config/www/kygl_v2/dist_front/;
  25.     #   try_files $uri $uri/ /index.html?s=$uri&$args;
  26.     #   index index.html index.htm index.php;
  27.     #}
  29.     #后端
  30.     location /api {
  31.        proxy_pass http://myserver;
  32.        index  index.html index.htm;
  33.     }
  34.     location /auth {
  35.        proxy_pass http://myserver;
  36.        index  index.html index.htm;
  37.     }
  38.     
  39.     #下面是配置访问swagger
  40.     location /swagger-ui.html {
  41.         proxy_pass http://myserver;
  42.         index  index.html index.htm;
  43.     }
  45.     location /webjars {
  46. 	   proxy_pass http://myserver;
  47.         index  index.html index.htm;
  48.     }
  50.     location /swagger-resources {
  51.       proxy_pass http://myserver;
  52.       index  index.html index.htm;
  53.     }
  55.     location /v2 {
  56.       proxy_pass http://myserver;
  57.       index  index.html index.htm;
  58.     }
  59. }

3、记得每次修改nginx的相关配置，都需要重新加载下

  1. //进入nginx容器
  2. docker exec -it nginx bash
  3. //测试，看下配置文件是否有问题
  4. nginx -t
  5. //重新加载
  6. nginx -s reload

如果遇到修改配置后，没有生效，请执行下面的命令

  1. nginx -s reopen
  2. nginx -s stop //此命令执行后，会退出容器，重新进入即可
  3. nginx -reload

部署后端（SpringBoot项目）

如果你是把各种服务放到了docker中，请选择方案一；如果你把各种服务安装到了服务器中，请选择方案二；

下面的所有步骤将以我的github项目为例

克隆项目

  1. git clone https://github.com/zglgithubx/ourchat.git

切换到分支develop

  1. git checkout develop
方案一

这个方案用到了一个脚本文件demo.sh，一个Dockerfile文件，说下demo.sh脚本都做了哪些工作：执行Dockerfile文件构建CentoS镜像，在镜像中安装了vim 、git、jdk 、maven—>根据centos镜像启动了一个容器---->在centos容器中拉取项目—>将项目打包成jar包—>启动项目jar包

1、准备文件

下面是脚本文件demo.sh和Dockerfile，部署时请将这两文件放到后端的根目录下

注：如果部署自己的项目需将SERVER_NAME 、JAR_PATH、Root_File_Name参数修改

  1. #!/bin/bash
  3. # 镜像名字
  4. IMAGE_NAME=centos7_mvn_git_java8
  6. # docker 容器名字或者jar名字，这里都命名为这个（*必填）
  7. SERVER_NAME=ourchat
  9. #这里的JAR_PATH为jar包所在位置，这路径是jar相对于脚本文件的路径。（*必填）
  10. JAR_PATH=./target/demo-0.0.1-RELEASE.jar
  12. #项目根目录文件夹名称（*必填）
  13. Root_File_Name=ourchat
  15. profile=$2
  16. port=$3
  17. #Xms=$4
  18. #Xmx=$5
  20. #使用说明，用来提示输入参数
  21. usage() {
  22.     echo "Usage: sh 执行脚本.sh [init|start|stop|restart|status|pull] [profile] [port]"
  23.     exit 1
  24. }
  26. #初始化——构建镜像和容器(在宿主机执行)
  27. init(){
  28.   #容器id
  29.   CID=$(docker ps | grep "$SERVER_NAME" | awk '{print $1}')
  30.   #镜像id
  31.   IID=$(docker images | grep "$IMAGE_NAME" | awk '{print $3}')
  32. 	# 构建docker镜像
  33. 	if [ -n "$IID" ]; then
  34. 		echo "Exit $SERVER_NAME image，IID=$IID"
  35. 	else
  36. 		echo "NOT exit $SERVER_NAME image，start build image..."
  37. 		# 根据项目个路径下的Dockerfile文件，构建镜像
  38. 		docker build -t $IMAGE_NAME .
  39. 		echo "$SERVER_NAME image has been builded"
  40. 	fi
  42. 	if [ -n "$CID" ]; then
  43. 			echo "Exit $SERVER_NAME container，CID=$CID.   ---Remove container"
  44. 			docker stop $SERVER_NAME   # 停止运行中的容器
  45. 			docker rm $SERVER_NAME     ##删除原来的容器
  46. 	fi
  48. 	# 构建容器
  49. 	echo "$SERVER_NAME container,start build..."
  50. 	# 运行容器
  51. 	 # --name 容器的名字
  52. 	 #   -d   容器后台运行
  53. 	 #   -p   指定容器映射的端口和主机对应的端口
  54. 	 #   -v   将主机的目录挂载到容器的目录中（不可少）
  55. 	docker run -e TZ="Asia/Shanghai" -id -m 512M --memory-swap=1G --name $SERVER_NAME -v $PWD/../:/project/$Root_File_Name $IMAGE_NAME
  56. 	echo "$SERVER_NAME container build end"
  57. }
  59. #检查程序是否在运行
  60. is_exist(){
  61.   pid=`ps -ef|grep $JAR_PATH|grep -v grep|awk '{print $2}' `
  62.   #如果不存在返回1，存在返回0
  63.   if [ -z "${pid}" ]; then
  64.    return 1
  65.   else
  66.     return 0
  67.   fi
  68. }
  70. #启动方法
  71. start(){
  72.   is_exist
  73.   if [ $? -eq "0" ]; then
  74.     echo "${SERVER_NAME} is already running. pid=${pid} ."
  75.   else
  76.     echo --------Starting application --------
  77.     nohup java -server -XX:-DisableExplicitGC -XX:+UseParNewGC -XX:+UseConcMarkSweepGC -jar $JAR_PATH --spring.profiles.active=${profile:-dev} --server.port=${port:-8000} > start.log 2>&1 &
  78.     echo --------------Started!---------------
  80.   fi
  81. }
  83. #停止方法
  84. stop(){
  85.   is_exist
  86.   if [ $? -eq "0" ]; then
  87.     kill -9 $pid
  88.     echo -----------Application Stopped------------
  89.   else
  90.     echo "${JAR_PATH} is not running"
  91.   fi
  92. }
  94. #输出运行状态
  95. status(){
  96.   is_exist
  97.   if [ $? -eq "0" ]; then
  98.     echo "${JAR_PATH} is running. Pid is ${pid}"
  99.   else
  100.     echo "${JAR_PATH} is NOT running."
  101.   fi
  102. }
  104. #重启
  105. restart(){
  106.   stop
  107.   start
  108. }
  110. #mvn
  111. pull(){
  112.   echo "----------git：find status---------"
  113.   git status
  114.   echo "----------git：pull new coads---------"
  115.   git pull origin develop
  116.   if [ $? -ne 0 ]; then
  117.     exit
  118.   fi
  119.   echo "----------mvn clean package -Dmaven.test.skip=true---------"
  120.   mvn clean package -Dmaven.test.skip=true
  121.   if [ $? -ne 0 ]; then
  122.     exit
  123.   fi
  124.   echo "----------Preparing start application ---------"
  125.   is_exist
  126.   if [ $? -eq "0" ]; then
  127.     restart
  128.   else
  129.     start
  130.   fi
  131. }
  133. #根据输入参数，选择执行对应方法，不输入则执行使用说明
  134. case "$1" in
  135.   "init")
  136.     init
  137.     ;;
  138.   "start")
  139.     start
  140.     ;;
  141.   "stop")
  142.     stop
  143.     ;;
  144.   "status")
  145.     status
  146.     ;;
  147.   "restart")
  148.     restart
  149.     ;;
  150.   "pull")
  151.     pull
  152.     ;;
  153.   *)
  154.     usage
  155.     ;;
  156. esac

Dockerfile

  1. FROM centos:latest
  2. RUN yum -y update \
  3.     && yum -y install vim \
  4.     && yum -y install git \
  5.     && yum -y install java-1.8.0-openjdk-devel.x86_64 \
  6.     && yum install -y maven \
  7.     && mkdir ~/.m2
  8. RUN echo '<?xml version="1.0" encoding="UTF-8"?><settings xmlns="http://maven.apache.org/SETTINGS/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd"><mirrors><mirror><id>alimaven</id><mirrorOf>central</mirrorOf><name>aliyun maven</name><url>http://maven.aliyun.com/nexus/content/repositories/central/</url></mirror></mirrors></settings>' > ~/.m2/settings.xml

2、初始化、构建镜像

切换到后端项目根目录

  1. cd xxxx/ourchat_api/

执行初始化命令

  1. sh demo.sh init

完成后，会有成功的提示

3、查看容器是否启动

  1. docker ps

status为up 即为启动成功

4、进入容器

  1. docker exec -it ourchat bash

5、切换到容器中的项目后端目录

  1. cd project/ourchat/ourchat_api/

6、脚本命令介绍

到这一步骤，环境基本都搭建完毕了，下面介绍脚本的命令

上面的初始化命令只需要执行一次，之后代码更新，只需要执行：

  1. 注：下面的命令需要用ssh的方式和远程仓库建立连接，即配置centos容器中git,生成ssh key，将id.res_pub文件内容的key添加到github或coding服务器的个人账户中
  2. #拉取新代码，重新打包项目，并重新启动
  3. sh demo.sh pull

下面的命令是脚本的其他命令：

  1. #查看项目启动状态
  2. sh demo.sh status
  3. #启动项目，后面的参数是选填的,dev：环境，8000：项目端口号
  4. sh demo.sh start dev 8000
  5. #停止项目
  6. sh demo.sh stop
  7. #重新启动项目
  8. sh demo.sh restart
方案二

方案一的好处有很多，项目交付时，服务器可能会发生迁移，新服务器不用再手动安装一些环境，只需要安装docker ,剩下的环境，执行Dockerfile就可以了。

方案二适合在个人服务器部署个人项目，不需要考虑服务器的迁移，可以把所有环境都装到服务器，节省空间

你如果选择了方案二，默认你已经把mysql、redis、及git都已经安装完毕

为了能够启动后端项目，还需要安装maven、jdk

1、安装maven

  1. yum install maven

2、安装jdk1.8

  1. install java-1.8.0-openjdk-devel.x86_64

3、准备脚本文件

其实这文件是根据demo.sh修改的，也是只需要把这个文件放到后端项目的根目录，如果自己使用只需要更改SERVER_NAME、JAR_PATH这两个参数

ourchat.sh

  1. #!/bin/bash
  3. # docker 容器名字或者jar名字，这里都命名为这个
  4. SERVER_NAME=ourchat
  6. #这里的JAR_PATH为jar包所在位置
  7. JAR_PATH=./target/demo-0.0.1-RELEASE.jar
  9. profile=$2
  10. port=$3
  11. #Xms=$4
  12. #Xmx=$5
  14. #使用说明，用来提示输入参数
  15. usage() {
  16.     echo "Usage: sh 执行脚本.sh [build|start|stop|restart|status|pull] [profile] [port]"
  17.     exit 1
  18. }
  19. build(){
  20.   echo "----------mvn clean package -Dmaven.test.skip=true---------"
  21.   mvn clean package -Dmaven.test.skip=true
  22.   if [ $? -ne 0 ]; then
  23.     exit
  24.   fi
  25.   echo "----------Preparing start application ---------"
  26.   is_exist
  27.   if [ $? -eq "0" ]; then
  28.     restart
  29.   else
  30.     start
  31.   fi
  32. }
  34. #检查程序是否在运行
  35. is_exist(){
  36.   pid=`ps -ef|grep $JAR_PATH|grep -v grep|awk '{print $2}' `
  37.   #如果不存在返回1，存在返回0
  38.   if [ -z "${pid}" ]; then
  39.    return 1
  40.   else
  41.     return 0
  42.   fi
  43. }
  45. #启动方法
  46. start(){
  47.   is_exist
  48.   if [ $? -eq "0" ]; then
  49.     echo "${SERVER_NAME} is already running. pid=${pid} ."
  50.   else
  51.     echo --------Starting application --------
  52.     nohup java -server -Xms512m -Xmx512m -XX:SurvivorRatio=4 -Xss256k -XX:PermSize=256m -XX:MaxPermSize=512m -XX:-DisableExplicitGC -XX:+UseParNewGC -XX:+UseConcMarkSweepGC -jar $JAR_PATH --spring.profiles.active=${profile:-prod} --server.port=${port:-8000}> start.log 2>&1 &
  53.     echo --------------Started!---------------
  54.   fi
  55. }
  57. #停止方法
  58. stop(){
  59.   is_exist
  60.   if [ $? -eq "0" ]; then
  61.     kill -9 $pid
  62.     echo -----------Application Stopped------------
  63.   else
  64.     echo "${JAR_PATH} is not running"
  65.   fi
  66. }
  68. #输出运行状态
  69. status(){
  70.   is_exist
  71.   if [ $? -eq "0" ]; then
  72.     echo "${JAR_PATH} is running. Pid is ${pid}"
  73.   else
  74.     echo "${JAR_PATH} is NOT running."
  75.   fi
  76. }
  78. #重启
  79. restart(){
  80.   stop
  81.   start
  82. }
  84. #mvn
  85. pull(){
  86.   echo "----------git：find status---------"
  87.   git status
  88.   echo "----------git：pull new coads---------"
  89.   git pull origin develop
  90.   if [ $? -ne 0 ]; then
  91.     exit
  92.   fi
  93.   echo "----------mvn clean package -Dmaven.test.skip=true---------"
  94.   mvn clean package -Dmaven.test.skip=true
  95.   if [ $? -ne 0 ]; then
  96.     exit
  97.   fi
  98.   echo "----------Preparing start application ---------"
  99.   is_exist
  100.   if [ $? -eq "0" ]; then
  101.     restart
  102.   else
  103.     start
  104.   fi
  105. }
  107. #根据输入参数，选择执行对应方法，不输入则执行使用说明
  108. case "$1" in
  109.   "build")
  110.     build
  111.     ;;
  112.   "start")
  113.     start
  114.     ;;
  115.   "stop")
  116.     stop
  117.     ;;
  118.   "status")
  119.     status
  120.     ;;
  121.   "restart")
  122.     restart
  123.     ;;
  124.   "pull")
  125.     pull
  126.     ;;
  127.   *)
  128.     usage
  129.     ;;
  130. esac

4、在项目后端根目录执行build命令

这个命令会将项目打包并运行

  1. sh ourchat.sh build

其他命令同方案一中介绍的命令一样

项目代码更新后，重新部署时，只需要执行

  1. sh ourchat.sh pull

部署前端（Vue项目）

前端的部署，不外乎将打包好的dist文件夹上传到服务器，可能有的人直接在服务器安装webpack,然后再安装一系列的前端需要的配置，使用git将项目拉取到服务器，然后在服务器运行打包命令。我感觉前端的部署不应该那么复杂，有人可能要说了，直接把dist包每次在本地打包，然后复制到服务器的指定目录不就好了，这都2021年了，其实也不需要那么步骤。下面我介绍一款前端部署插件，可以用来简化这些步骤。

安装fe-deploy-cli
  1. //此为全局安装，一次安装受益终身
  2. npm i fe-deloy-cli -g

安装之后，在前端项目根目录打开命令行

执行：

  1. deploy init

执行完之后，在项目根目录会生成：deploy文件夹

文件deploy.config.js大概是这样

  1. module.exports = {
  2.   privateKey: '', //（选填） 本地私钥地址，位置一般在C:/Users/xxx/.ssh/id_rsa，非必填，有私钥则配置
  3.   passphrase: '', // （选填）本地私钥密码，非必填，有私钥则配置
  4.   projectName: 'xxxx', // 项目名称
  5.   // 根据需要进行配置，如只需部署prod线上环境，请删除dev测试环境配置，反之亦然，支持多环境部署
  6.   dev: { // 开发环境
  7.     name: '开发环境',
  8.     script: "npm run build", // 测试环境打包脚本
  9.     host: 'xxxx', // 测试服务器地址
  10.     port: xx, // ssh port，一般默认22
  11.     username: 'xxxx', // 登录服务器用户名
  12.     password: 'xxxxx', // 登录服务器密码
  13.     distPath: 'dist',  // 本地打包dist目录
  14.     webDir: '/MyProject/docker/nginx/html',  // // 测试环境服务器地址
  15.   },
  16.   prod: {  // 线上环境
  17.     同上
  18.   }
  19.   // 再还有多余的环境按照这个格式写即可
  20. }

上面变量都有注释，可以只配置一个环境，只需要把prod的内容删除，如果prod环境你没有配执行时会有报错。

配置完，在项目根目录执行

  1. deploy dev //这代表打包开发环境

执行之后，需要你确认下，输入yes就行，执行过程为：打包前端项目–>压缩打包文件–>压缩包上传到指定服务器的文件夹–>解压—>部署成功

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/weixin_44932487/article/details/121212351

内容来源于网络，如有侵权，请联系作者删除！

linuxcentosdocker

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com