Docker部署快搭鸭

前置准备

卸载服务器已安装的老版本Docker(没有安装过则跳过)

老版本的docker也被叫做：docker或docker-engine。如果你安装这些版本，那么请卸载它，以及它的依赖项目。

1.停用全部运行中的容器:

docker stop $(docker ps -a -q)

2.删除全部容器：

docker rm $(docker ps -a -q)

3、删除所有镜像

docker rmi -f $(docker images -qa)

4、卸载docker

yum remove docker  docker-client  docker-client-latest docker-common  docker-latest  docker-latest-logrotate  docker-logrotate  docker-selinux  docker-engine-selinux  docker-engine
umount /var/lib/docker/devicemapper
rm -rf /etc/systemd/system/docker.service.d
rm -rf /var/lib/docker
rm -rf /var/run/docker
rm -rf /var/lib/dockershim
rm -rf /etc/docker

5、查看系统已经安装了哪些docker包

yum list installed | grep docker

6、卸载相关包

yum remove docker相关包名

Linux安装Docker

默认安装：

yum install docker-ce -y

curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun

如果需要安装在其他位置：

1.建立软连接

ln -s /var/lib/docker 自定义安装路径

2.然后再执行默认安装指令

Linux安装Docker-Compose

sudo curl -L https://get.daocloud.io/docker/compose/releases/download/1.25.1/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose

对Docker-Compose授权

sudo chmod +x /usr/local/bin/docker-compose

默认安装路径为/usr/local/bin，如需更改就把以上两个指令中的默认路径替换为自定义路径即可

启动Docker

systemctl start docker

设置开机自启

systemctl enable docker.service

Windows与MacOS安装Docker Desktop：https://www.docker.com

Windows系统在安装Docker时需要在BIOS中开启虚拟化。

预留端口

部署前检查以下端口是否被占用，端口查询指令：

netstat -anp|grep 端口号

3306*（mysql服务）*
80、443*（nginx服务）*
6379*（redis服务）*
9000、9001*（minio服务）*
8080（快搭鸭）

如果所需端口被其他进程占用，可选择性的使用以下指令释放端口。

kill -9 进程PID

如果不想释放占用的进程，可以更改在docker文件夹中的docker-compose.yml配置文件。

3306端口被占用，更改第15行ports：- "自定义端口号:3306"。例如将mysql服务的端口改为3307则将配置文件修改为ports: - "3307:3306"，下同。

80、443端口被占用，更改第38-39行ports。

6379端口被占用，更改第56行ports。

9000、9001端口被占用，更改第74、76行ports。

8080端口被占用，更改第108行ports。

1.打包后端项目

使用idea打开后端项目，在maven插件中点击切换到Profiles下的prod，再选择KuaiDaYa->->Lifecycle->package（打包前建议先使用clean）。

等待项目打包完成后，在kuaidaya-admin文件夹中添加Dockerfile文件，文件内容如下：

FROM anapsix/alpine-java:8_server-jre_unlimited

MAINTAINER kuaidaya

RUN mkdir -p /kuaidaya/server
RUN mkdir -p /kuaidaya/server/logs

WORKDIR /kuaidaya/server

EXPOSE 8080

ADD ../../kuaidaya-admin/target/kuaidaya-admin.jar ./app.jar

ENTRYPOINT ["java", "-Djava.security.egd=file:/dev/./urandom", "-jar", "app.jar"]

进入项目根目录下的script/docker文件夹中，在该文件夹中打开shell终端（Windows8.1以上可使用系统自带的Powershell，其他版本Windows自行安装shell终端），在终端中执行后续操作。

在本地Docker仓库创建项目镜像，并从本地Docker仓库中将该镜像提取为tar包：

./manage.sh pa

执行完毕后，确认当前文件夹中项目tar包完整性，一切无误后，将整个docker文件夹复制到所需部署的服务器中。

2.服务器端装载镜像

检查script/docker/docker-compose.yml文件第11行MYSQL_ROOT_PASSWORD是否与kuaidaya-admin/src/main/resources/application-prod.yml中的数据库密码一致性，以及script/docker/redis中requirepss与kuaidaya-admin/src/main/resources/application-prod.yml中redis密码的一致性。

完成上一步后在服务器端的终端中打开docker文件夹，首先对两个脚本文件授权：

sudo chmod +x ./manage.sh ./deploy.sh

将本地打包好的项目镜像装载到服务器的docker仓库中：

./manage.sh la

3.后端项目启动

镜像装载完毕后放置挂载文件：

./deploy.sh mount

启动mysql

./deploy.sh mysql

启动nginx-web

./deploy.sh nginx-web

启动redis

./deploy.sh redis

启动minio

./deploy.sh minio

启动程序模块

./deploy.sh start

停止程序模块

./deploy.sh stop

关闭所有模块

./deploy.sh stopall

重启单个服务

docker-compose restart 服务名								--（例：docker-compose restart nginx-web）

4.前端项目打包

在终端中打开kuaidaya-ui文件夹

安装前端依赖

npm install

前端项目打包

npm run build:prod

打包完成后将目录下的dist文件夹复制到服务器中nginx配置的目录下即可，PC端路径/docker/kuaidaya-web/html/kuaidaya-ui/，移动端路径***/docker/kuaidaya-web/html/kuaidaya-app/***。

5.相关脚本

manage.sh

#!/bin/bash

usage() {
   echo "Usage: sh 执行脚本.sh [install|pa|pm|la|lm|p-all|l-all]"
   exit 1
}

installDocker(){
    yum install docker-ce -y & ce_pid=$(jobs -p | tail -1)
    wait "${ce_pid}"
    # install docker
    curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun
}

installDockerCompose(){
    # install docker-compose
    sudo curl -L https://get.daocloud.io/docker/compose/releases/download/1.25.1/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
    # add executable permissions
    sudo chmod +x /usr/local/bin/docker-compose
    # start docker
    systemctl start docker
    #setting autostart
    systemctl enable docker.service
}

#only package admin's image
pa(){
    # package the image
    output=`docker build -t kuaidaya/kuaidaya-server -f ../../kuaidaya-admin/Dockerfile ../../`
    # save image locally
    docker save kuaidaya/kuaidaya-server>kuaidaya-server.tar
}

#only package monitor's image
pm(){
    # package the image
    output=`docker build -t kuaidaya/kuaidaya-monitor-admin -f ../../kuaidaya-extend/kuaidaya-monitor-admin/Dockerfile ../../`
    # save image locally
    docker save kuaidaya/kuaidaya-monitor-admin>kuaidaya-monitor.tar
}

#package all images
packageAll(){

    output=`docker build -t kuaidaya/kuaidaya-server -f ../../kuaidaya-admin/Dockerfile ../../`

    docker save kuaidaya/kuaidaya-server>kuaidaya-server.tar

    output=`docker build -t kuaidaya/kuaidaya-monitor-admin -f ../../kuaidaya-extend/kuaidaya-monitor-admin/Dockerfile ../../`

    docker save kuaidaya/kuaidaya-monitor-admin>kuaidaya-monitor.tar
}

la(){
    docker load<kuaidaya-server.tar
}

lm(){
    docker load<kuaidaya-monitor.tar
}

loadAll(){
    docker load<kuaidaya-server.tar
    docker load<kuaidaya-monitor.tar
}

progress() {
        #进度条程序
        local main_pid=$1
        local length=20
        local ratio=1
        while [ "$(ps -p ${main_pid} | wc -l)" -ne "1" ] ; do
                mark='>'
                progress_bar=
                for i in $(seq 1 "${length}"); do
                        if [ "$i" -gt "${ratio}" ] ; then
                                mark='-'
                        fi
                        progress_bar="${progress_bar}${mark}"
                done
                printf "Progress: ${progress_bar}\r"
                ratio=$((ratio+1))
                #ratio=`expr ${ratio} + 1`
                if [ "${ratio}" -gt "${length}" ] ; then
                        ratio=1
                fi
                sleep 0.1
        done
}



#根据输入参数，选择执行对应方法，不输入则执行使用说明
case "$1" in
"install")
   installDocker & docker_pid=$(jobs -p | tail -1)
   wait "${docker_pid}"
   installDockerCompose
   printf "Progress: install success                \n"
;;
"pa")
   pa
   printf "Progress: package admin success                \n"
;;
"pm")
   pm
   printf "Progress: package admin success                \n"
;;
"la")
    la & la_pid=$(jobs -p | tail -1)
    progress "${la_pid}" &
    progress_pid=$(jobs -p | tail -1)
    wait "${la_pid}"
    printf "Progress: load admin success                \n"
;;
"lm")
    lm & lm_pid=$(jobs -p | tail -1)
    progress "${lm_pid}" &
    progress_pid=$(jobs -p | tail -1)
    wait "${lm_pid}"
    printf "Progress: load monitor success                \n"
;;
"p-all")
    packageAll
    printf "Progress: package all success                \n"
;;
"l-all")
   loadAll & loadAll_pid=$(jobs -p | tail -1)
   progress "${loadAll_pid}" &
    progress_pid=$(jobs -p | tail -1)
    wait "${loadAll_pid}"
    printf "Progress: load all image success                \n"
;;
*)
   usage
;;
esac

deploy.sh

#!/bin/bash

#使用说明，用来提示输入参数
usage() {
   echo "Usage: sh 执行脚本.sh [port|mount|monitor|base|mysql|nginx-web|redis|minio|start|stop|stopall|rm|rmiNoneTag]"
   exit 1
}

#开启所需端口(生产环境不推荐开启)
port(){
    # mysql 端口
   firewall-cmd --add-port=3306/tcp --permanent
   # redis 端口
   firewall-cmd --add-port=6379/tcp --permanent
   # minio api 端口
   firewall-cmd --add-port=9000/tcp --permanent
   # minio 控制台端口
   firewall-cmd --add-port=9001/tcp --permanent
   # 重启防火墙
   service firewalld restart
}

##放置挂载文件
mount(){
   #挂载 nginx 配置文件
   if test ! -f "/docker/nginx/conf/nginx.conf" ;then
      mkdir -p /docker/kuaidaya-web/conf
      cp nginx/nginx.conf /docker/kuaidaya-web/conf/nginx.conf
   fi
   #挂载 redis 配置文件
   if test ! -f "/docker/redis/conf/redis.conf" ;then
      mkdir -p /docker/redis/conf
      cp redis/redis.conf /docker/redis/conf/redis.conf
   fi
   # license 公钥
   tar zxvf license.tgz -C /home
}

#启动基础模块
base(){
   docker-compose up -d mysql nginx-web redis minio
}

#启动mysql
mysql(){
   docker-compose up -d mysql
}
#启动nginx-web
nginx-web(){
   docker-compose up -d nginx-web
}
#启动redis
redis(){
   docker-compose up -d redis
}
#启动minio
minio(){
   docker-compose up -d minio
}

#启动基础模块
monitor(){
   docker-compose up -d kuaidaya-monitor-admin
}

#启动程序模块
start(){
   docker-compose up -d kuaidaya-server1
}

#停止程序模块
stop(){
   docker-compose stop kuaidaya-server1
}

#关闭所有模块
stopall(){
   docker-compose stop
}

#删除所有模块
rm(){
   docker-compose rm
}

#删除Tag为空的镜像
rmiNoneTag(){
   docker images|grep none|awk '{print $3}'|xargs docker rmi -f
}

#根据输入参数，选择执行对应方法，不输入则执行使用说明
case "$1" in
"port")
   port
;;
"mount")
   mount
;;
"base")
   base
;;
"mysql")
   mysql
;;
"nginx-web")
   nginx-web
;;
"redis")
   redis
;;
"minio")
   minio
;;
"monitor")
   monitor
;;
"start")
   start
;;
"stop")
   stop
;;
"stopall")
   stopall
;;
"rm")
   rm
;;
"rmiNoneTag")
   rmiNoneTag
;;
*)
   usage
;;
esac

前置准备​

卸载服务器已安装的老版本Docker(没有安装过则跳过)​

1.停用全部运行中的容器:​

2.删除全部容器：​

3、删除所有镜像​

4、卸载docker​

5、查看系统已经安装了哪些docker包​

6、卸载相关包​

Linux安装Docker​

Linux安装Docker-Compose​

启动Docker​

设置开机自启​

Windows与MacOS安装Docker Desktop：https://www.docker.com​

预留端口​

1.打包后端项目​

2.服务器端装载镜像​

3.后端项目启动​

4.前端项目打包​

5.相关脚本​

manage.sh​

deploy.sh​