Golang基于Gitlab CI/CD部署方案持续集成 (Continuous integration)是一种软件开发

概述

持续集成 (Continuous integration)是一种软件开发实践，即团队开发成员经常集成它们的工作，通过每个成员每天至少集成一次，也就意味着每天可能会发生多次集成。每次集成都通过自动化的构建（包括编译，发布，自动化测试）来验证，从而尽早地发现集成错误。

持续部署（continuous deployment）是通过自动化的构建、测试和部署循环来快速交付高质量的产品。某种程度上代表了一个开发团队工程化的程度，毕竟快速运转的互联网公司人力成本会高于机器，投资机器优化开发流程化相对也提高了人的效率，让 engineering productivity 最大化。

1. 环境准备

本次试验是基于Centos 7.3, docker 17.03.2-ce环境下的。docker的安装这里就不赘述了，提供了官方链接吧: Get Docker CE for CentOS

1.1. docker启动gitlab

启动命令如下：

1docker run --detach \

2--hostname gitlab.chain.cn \

3--publish 8443:443 --publish 8080:80 --publish 2222:22 \

4--name gitlab \

5--restart always \

6--volume /Users/zhangzc/gitlab/config:/etc/gitlab \

7--volume /Users/zhangzc/gitlab/logs:/var/log/gitlab \

8--volume /Users/zhangzc/gitlab/data:/var/opt/gitlab \

9gitlab/gitlab-ce

port，hostname, volume根据具体情况具体设置

1.2. docker启动gitlab-runner

启动命令如下：

1sudo docker run -d /

2--name gitlab-runner /

3--restart always /

4-v /Users/zhangzc/gitlab-runner/config:/etc/gitlab-runner /

5-v /Users/zhangzc/gitlab-runner/run/docker.sock:/var/run/docker.sock /

6gitlab/gitlab-runner:latest

volume根据具体情况具体设置

1.3. 用于集成部署的镜像制作

我们的集成和部署都需要放在一个容器里面进行，所以，需要制作一个镜像并安装一些必要的工具，用于集成和部署相关操作。目前我们的项目都是基于golang 1.9.2的，这里也就基于golang:1.9.2的镜像制定一个特定的镜像。

Dockerfile内容如下：

1# Base image: https://hub.docker.com/_/golang/

2FROM golang:1.9.2

3USER root

4# Install golint

5ENV GOPATH /go

6ENV PATH ${GOPATH}/bin:$PATH

7RUN mkdir -p /go/src/golang.org/x

8RUN mkdir -p /go/src/github.com/golang

9COPY source/golang.org /go/src/golang.org/x/

10COPY source/github.com /go/src/github.com/golang/

11RUN go install github.com/golang/lint/golint

12

13# install docker

14RUN curl -O https://get.docker.com/builds/Linux/x86_64/docker-latest.tgz \

15 && tar zxvf docker-latest.tgz \

16 && cp docker/docker /usr/local/bin/ \

17 && rm -rf docker docker-latest.tgz

18

19# install expect

20RUN apt-get update

21RUN apt-get -y install tcl tk expect

其中golint是用于golang代码风格检查的工具。
docker是由于需要在容器里面使用宿主的docker命令，这里就需要安装一个docker的可执行文件，然后在启动容器的时候，将宿主的 /var/run/docker.sock 文件挂载到容器内的同样位置。
expect是用于ssh自动登录远程服务器的工具，这里安装改工具是为了可以实现远程服务器端部署应用

另外，在安装golint的时候，是需要去golang.org下载源码的，由于墙的关系，go get命令是执行不了的。为了处理这个问题，首先通过其他渠道先下载好相关源码，放到指定的路径下，然后copy到镜像里，并执行安装即可。

下面有段脚本是用于生成镜像的：

1#!/bin/bash

2

3echo "提取构建镜像时需要的文件"

4source_path="source"

5mkdir -p $source_path/golang.org

6mkdir -p $source_path/github.com

7cp -rf $GOPATH/src/golang.org/x/lint $source_path/golang.org/

8cp -rf $GOPATH/src/golang.org/x/tools $source_path/golang.org/

9cp -rf $GOPATH/src/github.com/golang/lint $source_path/github.com

10

11echo "构建镜像"

12docker build -t go-tools:1.9.2 .

13

14echo "删除构建镜像时需要的文件"

15rm -rf $source_path

生成镜像后，推送到镜像仓库，并在gitlab-runner的服务器上拉取该镜像

本次试验的gitlab和gitlab-runner是运行在同一服务器的docker下的。

2. runner注册及配置 2.1. 注册

环境准备好后，在服务器上执行以下命令，注册runner：

1docker exec -it gitlab-runner gitlab-ci-multi-runner register

按照提示输入相关信息

1Please enter the gitlab-ci coordinator URL:

2# gitlab的url, 如：https://gitlab.chain.cn/

3Please enter the gitlab-ci token for this runner:

4# gitlab->你的项目->settings -> CI/CD ->Runners settings

5Please enter the gitlab-ci description for this runner:

6# 示例：demo-test

7Please enter the gitlab-ci tags for this runner (comma separated):

8# 示例：demo

9Whether to run untagged builds [true/false]:

10# true

11Please enter the executor: docker, parallels, shell, kubernetes, docker-ssh, ssh, virtualbox, docker+machine, docker-ssh+machine:

12# docker

13Please enter the default Docker image (e.g. ruby:2.1):

14# go-tools:1.9.2 (之前自己制作的镜像)

342d896b9db7f424d0ecfc5756d722e978d91908

token

成功后，可以看到gitlab->你的项目->settings -> CI/CD ->Runners settings 页面下面有以下内容：

8224476b4b3f066d136c5fac1a4a103d3fa16cea

runner注册成功

2.2. 配置

注册成功之后，还需要在原有的配置上做一些特定的配置，如下：

1[[runners]]

2 name = "demo-test"

3 url = "https://gitlab.chain.cn/"

4 token = "c771fc5feb1734a9d4df4c8108cd4e"

5 executor = "docker"

6 [runners.docker]

7 tls_verify = false

8 image = "go-tools:1.9.2"

9 privileged = false

10 disable_cache = false

11 volumes = ["/var/run/docker.sock:/var/run/docker.sock"]

12 extra_hosts = ["gitlab.chain.cn:127.0.0.1"]

13 network_mode = "host"

14 pull_policy = "if-not-present"

15 shm_size = 0

16 [runners.cache]

这里先解释下gitlab-runner的流程吧，gitlab-runner在执行的时候，会根据上面的配置启动一个容器，即配置中的go-tools:1.9.2，b其中所有的启动参数都会在[runners.docker]节点下配置好，包括挂载啊，网络啊之类的。容器启动成功之后，会使用这个容器去gitlab上pull代码，然后根据自己定义的规则进行检验，全部检测成功之后便是部署了。

volumes: 是为了在容器中可以执行宿主机的docker命令。

extra_hosts: 给gitlab添加个host映射，映射到127.0.0.1

network_mode: 令容器的网络与宿主机一致，只有这样才能通过127.0.0.1访问到gitlab。

pull_policy: 当指定的镜像不存在的话，则通过docker pull拉取

3. 定义规则

在gitlab项目根目录创建.gitlab-ci.yml文件，填写runner规则，具体语法课参考官方文档：https://docs.gitlab.com/ee/ci/yaml/

3.1. go集成命令

下面介绍几个golang常见的集成命令

包列表正如在官方文档中所描述的那样，go项目是包的集合。下面介绍的大多数工具都将使用这些包，因此我们需要的第一个命令是列出包的方法。我们可以用go list子命令来完成

1go list ./...

请注意，如果我们要避免将我们的工具应用于外部资源，并将其限制在我们的代码中。那么我们需要去除vendor 目录，命令如下：

1go list ./... | grep -v /vendor/

单元测试这些是您可以在代码中运行的最常见的测试。每个.go文件需要一个能支持单元测试的_test.go文件。可以使用以下命令运行所有包的测试:

1go test -short $(go list ./... | grep -v /vendor/)

数据竞争这通常是一个难以逃避解决的问题，go工具默认具有(但只能在linux / amd64、freebsd / amd64、darwin / amd64和windows / amd64上使用)

1go test -race -short $(go list . /…| grep - v /vendor/)

代码覆盖这是评估代码的质量的必备工具，并能显示哪部分代码进行了单元测试，哪部分没有。要计算代码覆盖率，需要运行以下脚本：

1PKG_LIST=$(go list ./... | grep -v /vendor/)

2for package in ${PKG_LIST}; do

3 go test -covermode=count -coverprofile "cover/${package##*/}.cov" "$package" ;

4done

5tail -q -n +2 cover/*.cov >> cover/coverage.cov

6go tool cover -func=cover/coverage.cov

如果我们想要获得HTML格式的覆盖率报告，我们需要添加以下命令：

1go tool cover -html=cover/coverage.cov -o coverage.html

构建最后一旦代码经过了完全测试，我们要对代码进行编译，从而构建可以执行的二进制文件。

1go build .

linter
这是我们在代码中使用的第一个工具:linter。它的作用是检查代码风格/错误。这听起来像是一个可选的工具，或者至少是一个“不错”的工具，但它确实有助于在项目上保持一致的代码风格。 linter并不是go本身的一部分，所以如果要使用，你需要手动安装它(之前的go-tools镜像我们已经安装过了)。使用方法相当简单:只需在代码包上运行它(也可以指向. go文件):

1$ golint -set_exit_status $(go list ./... | grep -v /vendor/)

注意-set_exit_status选项。默认情况下，golint仅输出样式问题，并带有返回值（带有0返回码），所以CI不认为是出错。如果指定了-set_exit_status，则在遇到任何样式问题时，golint的返回码将不为0。

3.2. Makefile

如果我们不想在.gitlab-ci.yml文件中写的太复杂，那么我们可以把持续集成环境中使用的所有工具，全部打包在Makefile中，并用统一的方式调用它们。

这样的话，.gitlab-ci.yml文件就会更加简洁了。当然了，Makefile同样也可以调用*.sh脚本文件

3.3. 配置示例 3.3.1. .gitlab-ci.yml

1image: go-tools:1.9.2

2

3stages:

4 - build

5 - test

6 - deploy

7

8before_script:

9 - mkdir -p /go/src/gitlab.chain.cn/ZhangZhongcheng /go/src/_/builds

10 - cp -r $CI_PROJECT_DIR /go/src/gitlab.chain.cn/ZhangZhongcheng/demo

11 - ln -s /go/src/gitlab.chain.cn/ZhangZhongcheng /go/src/_/builds/ZhangZhongcheng

12 - cd /go/src/_/builds/ZhangZhongcheng/demo

13

14unit_tests:

15 stage: test

16 script:

17 - make test

18 tags:

19 - demo

20

21race_detector:

22 stage: test

23 script:

24 - make race

25 tags:

26 - demo

27

28code_coverage:

29 stage: test

30 script:

31 - make coverage

32 tags:

33 - demo

34

35code_coverage_report:

36 stage: test

37 script:

38 - make coverhtml

39 only:

40 - master

41 tags:

42 - demo

43

44lint_code:

45 stage: test

46 script:

47 - make lint

48

49build:

50 stage: build

51 script:

52 - pwd

53 - go build .

54 tags:

55 - demo

56

57build_image:

58 stage: deploy

59 script:

60 - make build_image

61 tags:

62 - demo

3.3.2. Makefile

1PROJECT_NAME := "demo"

2PKG := "gitlab.chain.cn/ZhangZhongcheng/$(PROJECT_NAME)"

3PKG_LIST := $(shell go list ./... | grep -v /vendor/)

4GO_FILES := $(shell find . -name '*.go' | grep -v /vendor/ | grep -v _test.go)

5

6test: ## Run unittests

7 @go test -v ${PKG_LIST}

8

9lint: ## Lint the files

10 @golint ${PKG_LIST}

11

12race: ## Run data race detector

13 @go test -race -short ${PKG_LIST}

14

15coverage: ## Generate global code coverage report

16 ./scripts/coverage.sh;

17

18coverhtml: ## Generate global code coverage report in HTML

19 ./scripts/coverage.sh html;

20

21build_image:

22 ./scripts/buildDockerImage.sh

3.3.3. coverage.sh

1#!/bin/bash

2#

3# Code coverage generation

4

5COVERAGE_DIR="${COVERAGE_DIR:-coverage}"

6PKG_LIST=$(go list ./... | grep -v /vendor/)

7

8# Create the coverage files directory

9mkdir -p "$COVERAGE_DIR";

10

11# Create a coverage file for each package

12for package in ${PKG_LIST}; do

13 go test -covermode=count -coverprofile "${COVERAGE_DIR}/${package##*/}.cov" "$package" ;

14done ;

15

16# Merge the coverage profile files

17echo 'mode: count' > "${COVERAGE_DIR}"/coverage.cov ;

18tail -q -n +2 "${COVERAGE_DIR}"/*.cov >> "${COVERAGE_DIR}"/coverage.cov ;

19

20# Display the global code coverage

21go tool cover -func="${COVERAGE_DIR}"/coverage.cov ;

22

23# If needed, generate HTML report

24if [ "$1" == "html" ]; then

25 go tool cover -html="${COVERAGE_DIR}"/coverage.cov -o coverage.html ;

26fi

27

28# Remove the coverage files directory

29rm -rf "$COVERAGE_DIR";

3.3.4. buildDockerImage.sh

1#!/bin/bash

2

3#检测GOPATH

4echo "检测GOPATH"

5if [ -z "$GOPATH" ];then

6echo "GOPATH 未设定"

7exit 1

8else

9echo "GOPATH=$GOPATH"

10fi

11

12#初始化数据

13echo "初始化数据"

14new_version="1.0.0"

15old_version="1.0.0"

16golang_version="1.9.2"

17app_name="application"

18projust_root="demo"

19DOCKER_IMAGE_NAME="demo"

20REGISTRY_HOST="xxx.xxx.xxx.xxx:5000"

21path="/go/src/_/builds/ZhangZhongcheng/demo"

22

23

24#当前容器更换为旧标签

25echo "当前容器更换为旧标签"

26docker rmi $REGISTRY_HOST/$DOCKER_IMAGE_NAME:$old_version

27

28# 基于golang:1.9.2镜像启动的容器实例，编译本项目的二进制可执行程序

29echo "基于golang:1.9.2镜像启动的容器实例，编译本项目的二进制可执行程序"

30cd $path

31go build -o $app_name

32

33echo "检测 $app_name 应用"

34FILE="$path/$app_name"

35if [ -f "$FILE" ];then

36echo "$FILE 已就绪"

37else

38echo "$FILE 应用不存在"

39exit 1

40fi

41

42#docker构建镜像禁止在构建上下文之外的路径添加复制文件

43#所以在此可以用命令把需要的文件cp到 dockerfile 同目录内 ,构建完成后再用命令删除

44cd $path/scripts

45echo "提取构建时需要的文件"

46cp ../$app_name $app_name

47

48# 基于当前目录下的Dockerfile构建镜像

49echo "基于当前目录下的Dockerfile构建镜像"

50echo "docker build -t $REGISTRY_HOST/$DOCKER_IMAGE_NAME:$new_version ."

51docker build -t $REGISTRY_HOST/$DOCKER_IMAGE_NAME:$new_version .

52

53# 删除本次生成的可执行文件以及构建所需要的文件

54echo "删除本次生成的可执行文件以及构建所需要的文件"

55rm -rf $app_name

56rm -rf ../$app_name

57

58#查看镜像

59echo "查看镜像"

60docker images | grep $DOCKER_IMAGE_NAME

61

62#推送镜像

63echo "推送镜像"

64echo "docker push $REGISTRY_HOST/$DOCKER_IMAGE_NAME:$new_version"

65docker push $REGISTRY_HOST/$DOCKER_IMAGE_NAME:$new_version

66

67echo "auto deploy"

68./automationDeployment.sh $new_version $old_version

3.3.5. automationDeployment.sh

1#!/usr/bin/expect

2#指定shebang

3#设定超时时间为3秒

4set ip xxx.xxx.xxx.xxx

5set password "xxxxxxx"

6

7set new_version [lindex $argv 0]

8set old_version [lindex $argv 1]

9

10spawn ssh root@$ip

11expect {

12 "*yes/no" { send "yes\r"; exp_continue}

13 "*password:" { send "$password\r" }

14}

15expect "#*"

16send "cd /root/demo/\r"

17send "./docker_run_demo.sh $new_version $old_version\r"

18expect eof

3.3.6. Dockerfile

1FROM golang:1.9.2

2

3#定义环境变量 alpine专用

4#ENV TIME_ZONE Asia/Shanghai

5

6ADD application /go/src/demo/

7

8WORKDIR /go/src/demo

9

10ADD run_application.sh /root/

11RUN chmod 755 /root/run_application.sh

12CMD sh /root/run_application.sh

13

14EXPOSE 8080

3.3.7. run_application.sh

1#!/bin/bash

2

3#映射ip

4cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime

5

6cd /go/src/demo/

7

8./application

4. 结果

以下为部署成功后的截图：

15303ff258cc336107ffc1e0387f775b3d574fd3

result

原文发布时间为：2018-09-9

本文作者：ChainZhang

本文来自云栖社区合作伙伴“Golang语言社区”，了解相关信息可以关注“ Golang语言社区”。