Go语言 基于gin框架从0开始构建一个bbs server(八)- 部署

docker 部署一个简单的 web app

新建一个 简单的web工程

package main

import (
   "fmt"
   "net/http"
)

func main() {
   http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
      writer.Write([]byte("hello wuyue"))
   })

   server := &http.Server{
      Addr: ":8812",
   }
   fmt.Println("server startup")
   if err := server.ListenAndServe(); err != nil {
      fmt.Println("server listen error")
   }

}
复制代码

然后新建我们的Dockerfile

FROM golang:alpine
# 设置必要的环境变量
ENV GO111MODULE=on \
    CGO_ENABLED=0 \
    GOOS=linux \
    GOARCH=amd64

# 移动到工作目录 workdir 和cd 这个命令有点类似
WORKDIR /build

# 将当前目录下的代码复制到容器中
COPY . .


#将我们的代码编译成二进制可执行文件app
RUN go build -o app .

# 移动到用于存放生成的二进制文件的 /dist 目录
WORKDIR /dist

# 将二进制文件从build目录复制到这里 也就是复制到dist目录下
RUN cp /build/app .

# 声明服务端口8812
EXPOSE 8812

# 启动容器时运行的命令
CMD ["/dist/app"]
复制代码

看下目录结构：

然后输入命令：

docker build . -t simple_go_web_app

镜像制作完毕 我们就可以运行这个容器了

docker run -p 8814:8812 simple_go_web_app

端口A:端口B

注意了 B 是我们编写Dockerfile 时候的制定的端口号 8812 我们可以将这个端口映射到我们本机8814 这个端口上

看下效果：

这样做有啥好处呢？

你可以把你的代码 一起发给别人，即使别人没有装go环境，但是看到这个dockerfile ，也可以输入命令 将这个工程跑起来 很是方便

改进部署-分阶段构建

前面已经比较方便了，但是仔细一想 还是有不完美的地方，因为go语言编译以后 是一个可执行文件，最终跑起来的地方 并不需要go的编译环境，是个linux 就可以了

下面来改一下

# 代表这个镜像只参与编译过程
FROM golang:alpine AS builder
# 设置必要的环境变量
ENV GO111MODULE=on \
    CGO_ENABLED=0 \
    GOOS=linux \
    GOARCH=amd64

# 移动到工作目录 workdir 和cd 这个命令有点类似
WORKDIR /build

# 将当前目录下的代码复制到容器中
COPY . .

#将我们的代码编译成二进制可执行文件app
RUN go build -o app .

# 创建一个小的镜像 linux 最终跑起来的就是这个最小的镜像
FROM scratch

# 从builder镜像中 把build app 拷贝到当前目录
COPY --from=builder /build/app /

# 需要运行的命令
ENTRYPOINT ["/app"]

# 声明服务端口8812
EXPOSE 8812

# 启动容器时运行的命令
CMD ["/dist/app"]
复制代码

这里可以看一下 两种方式 镜像的差距有多大

给项目增加一些静态文件

我们就简单一点 用vue 默认生成的代码，直接放到我们项目中来

在路由中也注册一下：

r.LoadHTMLFiles("./html/dist/index.html")
r.Static("/css","./html/dist/css")
r.Static("/js","./html/dist/js")
r.Static("/img","./html/dist/img")

r.GET("/vue", func(context *gin.Context) {
   context.HTML(http.StatusOK, "index.html", nil)
})
复制代码

注意这种 这种属于不是前后端分离的项目了，现在应该企业级用这种方案的已经很少了，这里只是为了演示docker的功能使用，后面会介绍前后端分离的部署方式

附带其他静态文件的 docker 部署

编写一下我们项目中的dockerfile：

# 代表这个镜像只参与编译过程
FROM golang:alpine AS builder
# 设置必要的环境变量
ENV GO111MODULE=on \
    CGO_ENABLED=0 \
    GOOS=linux \
    GOARCH=amd64

# 移动到工作目录 workdir 和cd 这个命令有点类似
WORKDIR /build

# 复制项目中的 go.mod 和 go.sum 文件并下载依赖信息 之前那个简单的项目是没有第三方依赖的 所以可以忽略这个步骤
COPY go.mod .
COPY go.sum .

RUN go env -w GOPROXY=https://goproxy.cn,direct

RUN go mod download

# 将代码复制到容器中
COPY . .

#将我们的代码编译成二进制可执行文件bbs
RUN go build -o bbs .

# 创建一个小的镜像 linux 最终跑起来的就是这个最小的镜像
FROM scratch

# 拷贝静态文件
COPY config.yaml .
COPY ./html /html


# 从builder镜像中 把build bbs 拷贝到当前目录
COPY --from=builder /build/bbs /

# 需要运行的命令
ENTRYPOINT ["/bbs","config.yaml"]

# 声明服务端口8812
EXPOSE 8812

# 启动容器时运行的命令
CMD ["/dist/app"]
复制代码

然后

docker build . -t bbs_app

然后跑起来看下：

mysql 这边出错了 ，很显然docker容器里 要连我本机的mysql 是连接不上的，没关系，这里我们可以继续创建mysql的容器

可以先下载一个mysql的镜像

然后启动我们的容器：

docker run -itd --name mysql-test -p 3309:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql:8.0.18

我们以 root 123456 这个密码 即可登录 这个数据库了

同时来修改我们的yaml文件

这里主要是改一下我们的端口号和密码

这个时候你会发现至少本机是可以连上 docker中的mysql数据库了，只是还需要在这个数据库中 导入我们之前的bbs数据库而已

同样的 我们也搞个redis docker run -itd --name redis-test -p 16379:6379 redis

至此 我们本机的go程序就可以访问 docker里面的2个数据库了。

很方便。

修改dockerfile

上述的只是做到了 本机的go 访问 docker中的 数据库， 那我们还要做到， docker中的go 可以访问 docker中的 数据库

继续修改我们的yaml文件

mysql:
  host: mysql-docker
  port: 3306
  user: "root"
  password: "123456"
  dbname: "bbs"
  max_open_connection: 200
  max_idle_connection: 10
redis:
  host: redis-docker
  passowrd: ""
  port: 6379
  db: 0
  pool_size: 0
复制代码

注意了此时我们的host 都是字符串了，这个字符串我们可以随便定义， 唯一要注意的是端口号

这里的端口号 实际代表的是 容器的端口号，并不是容器映射到本机的端口号 这是不一样的！！！

修改好了以后 我们就可以 重新build 出一个镜像：

然后再次启动我们的容器：

docker run --link=mysql-test:mysql-docker --link=redis-test:redis-docker -p 8019:8016 bbs_app

其实就是加上了link参数而已 注意link后面的写法 A：B A： 代表是我们本地的容器名称 B： 这个代表我们yaml中配置的host名称

看到这里 也就代表运行成功了

访问一下 静态文件： 也是没问题的。

一些细节的注意

有些人可能会注意到 这里的dockerfile 里面的端口号 写错了啊 为啥 最终还能跑起来呢？ 其实expose 你就理解是一个注释的作用，她仅仅是告诉 阅读的人 这里要对外暴露 哪个端口号来服务

而最终你的容器跑在哪个端口上 还是由你启动容器的命令所决定的

给docker更换国内数据源

  "builder": {
    "gc": {
      "enabled": true,
      "defaultKeepStorage": "20GB"
    }
  },
  "registry-mirrors":[
    "https://docker.mirrors.ustc.edu.cn",
    "https://hub-mirror.c.163.com" 

   ],



  "debug": true,
  "experimental": false
}
复制代码

Docker Compose 部署

前面我们通过--link 来关联了几个容器 让整个项目可以跑起来，现在可以用compose来 取代上述的过程， 这个部署方案 会更加的方便好用

首先 我们准备一个sh脚本，这个脚本在github上有，大家可以自行下载。 主要作用就是可以做到 让一个 进程等带前面的进程启动完毕 以后再启动

wait-for.sh

#!/usr/bin/env bash
# Use this script to test if a given TCP host/port are available

WAITFORIT_cmdname=${0##*/}

echoerr() { if [[ $WAITFORIT_QUIET -ne 1 ]]; then echo "$@" 1>&2; fi }

usage()
{
    cat << USAGE >&2
Usage:
    $WAITFORIT_cmdname host:port [-s] [-t timeout] [-- command args]
    -h HOST | --host=HOST       Host or IP under test
    -p PORT | --port=PORT       TCP port under test
                                Alternatively, you specify the host and port as host:port
    -s | --strict               Only execute subcommand if the test succeeds
    -q | --quiet                Don't output any status messages
    -t TIMEOUT | --timeout=TIMEOUT
                                Timeout in seconds, zero for no timeout
    -- COMMAND ARGS             Execute command with args after the test finishes
USAGE
    exit 1
}

wait_for()
{
    if [[ $WAITFORIT_TIMEOUT -gt 0 ]]; then
        echoerr "$WAITFORIT_cmdname: waiting $WAITFORIT_TIMEOUT seconds for $WAITFORIT_HOST:$WAITFORIT_PORT"
    else
        echoerr "$WAITFORIT_cmdname: waiting for $WAITFORIT_HOST:$WAITFORIT_PORT without a timeout"
    fi
    WAITFORIT_start_ts=$(date +%s)
    while :
    do
        if [[ $WAITFORIT_ISBUSY -eq 1 ]]; then
            nc -z $WAITFORIT_HOST $WAITFORIT_PORT
            WAITFORIT_result=$?
        else
            (echo -n > /dev/tcp/$WAITFORIT_HOST/$WAITFORIT_PORT) >/dev/null 2>&1
            WAITFORIT_result=$?
        fi
        if [[ $WAITFORIT_result -eq 0 ]]; then
            WAITFORIT_end_ts=$(date +%s)
            echoerr "$WAITFORIT_cmdname: $WAITFORIT_HOST:$WAITFORIT_PORT is available after $((WAITFORIT_end_ts - WAITFORIT_start_ts)) seconds"
            break
        fi
        sleep 1
    done
    return $WAITFORIT_result
}

wait_for_wrapper()
{
    # In order to support SIGINT during timeout: http://unix.stackexchange.com/a/57692
    if [[ $WAITFORIT_QUIET -eq 1 ]]; then
        timeout $WAITFORIT_BUSYTIMEFLAG $WAITFORIT_TIMEOUT $0 --quiet --child --host=$WAITFORIT_HOST --port=$WAITFORIT_PORT --timeout=$WAITFORIT_TIMEOUT &
    else
        timeout $WAITFORIT_BUSYTIMEFLAG $WAITFORIT_TIMEOUT $0 --child --host=$WAITFORIT_HOST --port=$WAITFORIT_PORT --timeout=$WAITFORIT_TIMEOUT &
    fi
    WAITFORIT_PID=$!
    trap "kill -INT -$WAITFORIT_PID" INT
    wait $WAITFORIT_PID
    WAITFORIT_RESULT=$?
    if [[ $WAITFORIT_RESULT -ne 0 ]]; then
        echoerr "$WAITFORIT_cmdname: timeout occurred after waiting $WAITFORIT_TIMEOUT seconds for $WAITFORIT_HOST:$WAITFORIT_PORT"
    fi
    return $WAITFORIT_RESULT
}

# process arguments
while [[ $# -gt 0 ]]
do
    case "$1" in
        *:* )
        WAITFORIT_hostport=(${1//:/ })
        WAITFORIT_HOST=${WAITFORIT_hostport[0]}
        WAITFORIT_PORT=${WAITFORIT_hostport[1]}
        shift 1
        ;;
        --child)
        WAITFORIT_CHILD=1
        shift 1
        ;;
        -q | --quiet)
        WAITFORIT_QUIET=1
        shift 1
        ;;
        -s | --strict)
        WAITFORIT_STRICT=1
        shift 1
        ;;
        -h)
        WAITFORIT_HOST="$2"
        if [[ $WAITFORIT_HOST == "" ]]; then break; fi
        shift 2
        ;;
        --host=*)
        WAITFORIT_HOST="${1#*=}"
        shift 1
        ;;
        -p)
        WAITFORIT_PORT="$2"
        if [[ $WAITFORIT_PORT == "" ]]; then break; fi
        shift 2
        ;;
        --port=*)
        WAITFORIT_PORT="${1#*=}"
        shift 1
        ;;
        -t)
        WAITFORIT_TIMEOUT="$2"
        if [[ $WAITFORIT_TIMEOUT == "" ]]; then break; fi
        shift 2
        ;;
        --timeout=*)
        WAITFORIT_TIMEOUT="${1#*=}"
        shift 1
        ;;
        --)
        shift
        WAITFORIT_CLI=("$@")
        break
        ;;
        --help)
        usage
        ;;
        *)
        echoerr "Unknown argument: $1"
        usage
        ;;
    esac
done

if [[ "$WAITFORIT_HOST" == "" || "$WAITFORIT_PORT" == "" ]]; then
    echoerr "Error: you need to provide a host and port to test."
    usage
fi

WAITFORIT_TIMEOUT=${WAITFORIT_TIMEOUT:-15}
WAITFORIT_STRICT=${WAITFORIT_STRICT:-0}
WAITFORIT_CHILD=${WAITFORIT_CHILD:-0}
WAITFORIT_QUIET=${WAITFORIT_QUIET:-0}

# Check to see if timeout is from busybox?
WAITFORIT_TIMEOUT_PATH=$(type -p timeout)
WAITFORIT_TIMEOUT_PATH=$(realpath $WAITFORIT_TIMEOUT_PATH 2>/dev/null || readlink -f $WAITFORIT_TIMEOUT_PATH)

WAITFORIT_BUSYTIMEFLAG=""
if [[ $WAITFORIT_TIMEOUT_PATH =~ "busybox" ]]; then
    WAITFORIT_ISBUSY=1
    # Check if busybox timeout uses -t flag
    # (recent Alpine versions don't support -t anymore)
    if timeout &>/dev/stdout | grep -q -e '-t '; then
        WAITFORIT_BUSYTIMEFLAG="-t"
    fi
else
    WAITFORIT_ISBUSY=0
fi

if [[ $WAITFORIT_CHILD -gt 0 ]]; then
    wait_for
    WAITFORIT_RESULT=$?
    exit $WAITFORIT_RESULT
else
    if [[ $WAITFORIT_TIMEOUT -gt 0 ]]; then
        wait_for_wrapper
        WAITFORIT_RESULT=$?
    else
        wait_for
        WAITFORIT_RESULT=$?
    fi
fi

if [[ $WAITFORIT_CLI != "" ]]; then
    if [[ $WAITFORIT_RESULT -ne 0 && $WAITFORIT_STRICT -eq 1 ]]; then
        echoerr "$WAITFORIT_cmdname: strict mode, refusing to execute subprocess"
        exit $WAITFORIT_RESULT
    fi
    exec "${WAITFORIT_CLI[@]}"
else
    exit $WAITFORIT_RESULT
fi
复制代码

然后我们要准备一个sql， 在新启动的docker的mysql中，我们让这个mysql 可以执行这个sql 以保证 启动的时候可以帮我们 新建对应的数据库以及表 命名为 init.sql

-- create the databases
CREATE DATABASE IF NOT EXISTS bbs;
复制代码

这里为了简单 我就省略复制粘贴那些建表的语句了。大家知道意思即可

然后更新下我们的dockerfile

# 代表这个镜像只参与编译过程
FROM golang:alpine AS builder
# 设置必要的环境变量
ENV GO111MODULE=on \
    CGO_ENABLED=0 \
    GOOS=linux \
    GOARCH=amd64

# 移动到工作目录 workdir 和cd 这个命令有点类似
WORKDIR /build

# 复制项目中的 go.mod 和 go.sum 文件并下载依赖信息 之前那个简单的项目是没有第三方依赖的 所以可以忽略这个步骤
COPY go.mod .
COPY go.sum .

RUN go env -w GOPROXY=https://goproxy.cn,direct

RUN go mod download

# 将代码复制到容器中
COPY . .

#将我们的代码编译成二进制可执行文件bbs
RUN go build -o bbs .

# 创建一个小的镜像 linux 最终跑起来的就是这个最小的镜像
FROM debian:stretch-slim

# 拷贝静态文件
COPY wait-for.sh .
COPY config.yaml .
COPY ./html /html


# 从builder镜像中 把build bbs 拷贝到当前目录
COPY --from=builder /build/bbs /

# 一定不要忘记更新源 否则后面build的时候要卡很久
RUN echo 'deb http://mirrors.163.com/debian/ stretch main non-free contrib' > /etc/apt/sources.list
RUN echo 'deb http://mirrors.163.com/debian/ stretch-updates main non-free contrib' >> /etc/apt/sources.list
RUN echo 'deb http://mirrors.163.com/debian-security/ stretch/updates main non-free contrib' >> /etc/apt/sources.list



RUN set -eux; \
    apt-get update; \
    apt-get install -y \
        --no-install-recommends \
        netcat; \
        chmod 755 wait-for.sh

复制代码

大家可以仔细比较下 和我们之间--link的那种方式 dockerfile有啥不同

最后就是最关键的一步，新建我们的docker-compose.yaml 文件

version: "3.7"
services:
  mysql-test2:
    image: "mysql:8.0.18"
    ports:
      - "13306:3306"
    command: "--default-authentication-plugin=mysql_native_password --init-file /data/application/init.sql"
    environment:
      MYSQL_ROOT_PASSWORD: "123456"
      MYSQL_USER: "root"
      MYSQL_DATABASE: "bbs"
    volumes:
      - ./init.sql:/data/application/init.sql
  redis-test2:
    image: "redis:latest"
    ports:
      - "26379:6379"
  bbs_app2:
    build: .
    # 关键的就是在这里 确保我们的web进程 在mysql和redis启动之后
    command: sh -c "./wait-for.sh mysql-test2:3306 redis-test2:6379  -- ./bbs config.yaml"
    depends_on:
      - mysql-test2
      - redis-test2
    ports:
      - "8066:8016"
复制代码

然后输入 docker-compose up 即可。 很方便 比之前link的方式要方便不少

这里一定要注意

当你改变本地代码之后，先执行docker-compose build构建新的镜像，然后执行docker-compose up -d取代运行中的容器

否则 你会发现 docker 会一直使用之前build过的镜像，你修改的代码不会生效。！！

部署方案1

一般而言，我们可以在本机编译出linux下可运行的 文件以后 连同你的静态文件 一起通过ssh scp 拷贝到你的云服务器上

然后 谨记 nohup去启动他 即可， 这个比较简单

另外要记得 把日志重定向 到 某个文件里面。 否则你nohup启动的程序 你是看不到日志输出的

另外还可以用 Supervisor 来将一个普通的命令行进程 变成后台守护进程，并监控该进程的运行状态

当进程异常退出时，可以自动重启

这个方案 是目前主流的方案。

这里就不扩展讲了，有兴趣的可以自行搜索。

搭配nginx部署

这篇不讲的太细了，因为都是一些简单的nginx配置，随便一搜就可以，下面就是简单的给一些关键字让大家知道在nginx部署服务端程序的时候要做到哪些

nginx -t 检验配置文件是否写对 这个命令要谨记，免的一直配置错误

upstream backend 这个关键字 用于 做负载均衡使用，大家了解一下即可。

之前我们的go程序 里面还包含了一些静态文件，跟前端有关的。 之前的部署中 请求这些静态的界面 也是走的go的gin框架，其实是没有必要的

正常的企业级部署应该是 在nginx层面做分离，静态文件就直接走nginx的代理直接返回就行了，api请求才走你的服务端代码

对应的关键字

location ～ .*\.(gif|jpg|js|)

location try_files 避免刷新页面 404
复制代码

大家有需要自行搜索即可。

此外，如果你的前端页面和后端不在一个域名下，你可能要支持跨域

可以参考下面的开源库进行处理 其实就是加一个中间件 go跨域