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

站长

2023年02月19日 18:26 · 阅读数 49

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"]

看下目录结构：

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

然后输入命令：

docker build . -t simple_go_web_app

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

docker run -p 8814:8812 simple_go_web_app

端口A:端口B

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

看下效果：

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

这样做有啥好处呢？

你可以把你的代码一起发给别人，即使别人没有装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"]

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

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

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

给项目增加一些静态文件

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

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

在路由中也注册一下：

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

然后跑起来看下：

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

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

可以先下载一个mysql的镜像

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

然后启动我们的容器：

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

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

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

同时来修改我们的yaml文件

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

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

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

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

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

至此我们本机的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名称

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

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

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

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

一些细节的注意

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

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

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

给docker更换国内数据源

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

  "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跨域

转载自:https://juejin.cn/post/7040070748085420046

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

docker 部署一个简单的 web app

改进部署-分阶段构建

给项目增加一些静态文件

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

修改dockerfile

一些细节的注意

给docker更换国内数据源

Docker Compose 部署

部署方案1

搭配nginx部署

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