Golang 项目部署实战

标签：实战 ps target 部署 pid echo Golang sh fi

一直认为不懂部署的开发工程师不是好的开发工程师，以下以一些实例讲解自己在项目中的 Golang 后端部署的情况。

一般部署脚本应该具有构建、启动、停止、回滚已经查看记录日志等功能，以下分别将这些功能以单个脚本的形式给出，当然也可以写成Makefile 的形式。

单个部署脚本的形式，在一个目录下建立如下文件：

1.   bin # 目录，用于存放每次 build 之后存放的二进制文件
2.   app.log # 用来记录的日志文件
3.   log.sh # 实时查看日志
4.   build.sh # 构建
5.   run.sh # 启动某一次编译版本
6.   start.sh # 启动最新版本，并且备份之前前一次运行的版本
7.   shutdown.sh # 停止
8.   rollback.sh # 回滚到上一版本

本例中的 GOPATH=”/go”

log.sh 具体内容：

tail -f -n 200 app.log # 实时查看最后 200 条日志的情况

 

build.sh 具体内容：

1.   #!/bin/bash
2.    
3.   # 项目地址，/go 在 GOPATH 里面
4.   baseProjectDir="/go/src/monitor"
5.    
6.   # targetDir 编译后的二进制文件目录
7.   targetDir="bin"
8.    
9.   # branch 编译的分支
10.   branch="master"
11.    
12.   pwd=`pwd`
13.   # targetFile 编译后的输出文件名称
14.   targetFile=`basename $pwd`
15.    
16.   # buildPkg 编译的包名，main.go 所在的包
17.   buildPkg="monitor"
18.    
19.   # buildResult 编译结果
20.   buildResult=""
21.    
22.   if [ -n "$1" ]; then
23.   branch="$1"
24.   echo "Switch branch to ${branch}"
25.   else
26.   echo "Building Branch: ${branch}"
27.   fi
28.    
29.   gitPull() {
30.   pushd .
31.    
32.   cd "$baseProjectDir"
33.   git checkout "$branch"
34.   git pull
35.    
36.   popd
37.   }
38.    
39.   goBuild() {
40.   buildResult=`go build -o "${targetDir}/${targetFile}" "$buildPkg" 2>&1`
41.    
42.   if [ -z "$buildResult" ]; then
43.   buildResult="success"
44.   fi
45.   }
46.    
47.   gitPull
48.   goBuild
49.    
50.   if [ "$buildResult" = "success" ]; then
51.   cp ${targetDir}/${targetFile} ${targetFile}-new
52.   chmod +x ${targetFile}-new
53.   else
54.   echo "build error $buildResult"
55.   exit
56.   fi
57.    
58.   echo "All Complete"

run.sh 具体内容：

1.   #!/bin/bash
2.    
3.   # 以后台方式启动程序，并且将日志记录到 app.log
4.   nohup ./$1 >> app.log &

start.sh 具体内容：

1.   #!/bin/bash
2.    
3.   pwd=`pwd`
4.   target=`basename $pwd`
5.   # kill
6.   pid=`ps -C ${target} -o pid=`
7.   if [ -n "$pid" ]; then
8.   echo "Stopping old version, PID: ${pid}"
9.   if [ "$1" = "-f" ]; then
10.   # force shutdown
11.   echo "Force shutdown..."
12.   kill -9 $(ps -C ${target} -o pid=)
13.   else
14.   kill -s 2 $(ps -C ${target} -o pid=)
15.   fi
16.   # wait for program to stop
17.   pid=`ps -C ${target} -o pid=`
18.   while [ -n "$pid" ]; do
19.   sleep 1
20.   done
21.   fi
22.    
23.   # upgrade
24.   if [ -f "${target}-new" ]; then
25.   echo "Upgrading..."
26.   if [ -f "${target}-backup" ]; then
27.   backupdt=`date +%Y%m%d-%H`
28.   mv "${target}-backup" "${target}-backup-${backupdt}"
29.   fi
30.    
31.   mv ${target} ${target}-backup
32.   mv ${target}-new ${target}
33.    
34.   echo "Upgrade Complete"
35.   fi
36.    
37.   # run
38.   echo "Starting..."
39.   ./run.sh ${target}
40.   echo "Done"

shutdown.sh 具体内容：

1.   #!/bin/bash
2.    
3.   pwd=`pwd`
4.   target=`basename $pwd`
5.    
6.   # kill
7.   pid=`ps -C ${target} -o pid=`
8.   if [ -n "$pid" ]; then
9.    
10.   echo "Stopping old version, PID: ${pid}"
11.   if [ "$1" = "-f" ]; then
12.   # force shutdown
13.   echo "Force shutdown..."
14.   kill -9 $(ps -C ${target} -o pid=)
15.   else
16.   kill -s 2 $(ps -C ${target} -o pid=)
17.   fi
18.    
19.   # wait for program to stop
20.   pid=`ps -C ${target} -o pid=`
21.   while [ -n "$pid" ]; do
22.   sleep 1
23.   done
24.    
25.   fi
26.    
27.   echo "Done"

需要注意的是 kill -s 2 发送的是 Interrupt 中断信号，在项目中要有监听该信号的处理程序，eg:

1.   package main
2.    
3.   import (
4.   "log"
5.   "os"
6.   "os/signal"
7.    
8.   "github.com/robfig/cron"
9.   )
10.    
11.   func main() {
12.   i := 0
13.   c := cron.New()
14.   spec := "*/3 * * * * ?"
15.   c.AddFunc(spec, func() {
16.   i++
17.   log.Println("cron running:", i)
18.   })
19.   c.Start()
20.    
21.   go signalListen()
22.    
23.   select {}
24.   }
25.    
26.   func signalListen() {
27.   c := make(chan os.Signal)
28.   // 监听 os.Interrupt 并且退出程序
29.   signal.Notify(c, os.Interrupt, os.Kill)
30.   for {
31.   <-c
32.   os.Exit(0)
33.   }
34.   }

rollback.sh 具体内容：

1.   #!/bin/bash
2.    
3.   pwd=`pwd`
4.   target=`basename $pwd`
5.    
6.   # Kill running program
7.   pid=`ps -C ${target} -o pid=`
8.   if [ -n "$pid" ]; then
9.    
10.   echo "Stopping old version, PID: ${pid}"
11.   if [ "$1" = "-f" ]; then
12.   # force shutdown
13.   echo "Force shutdown..."
14.   kill $(ps -C ${target} -o pid=)
15.   else
16.   kill -s 2 $(ps -C ${target} -o pid=)
17.   fi
18.    
19.   # wait for program to stop
20.   pid=`ps -C ${target} -o pid=`
21.   while [ -n "$pid" ]; do
22.   sleep 1
23.   done
24.   fi
25.    
26.   # Rollback
27.   if [ -f "${target}-backup" ]; then
28.   echo "Rolling back..."
29.   if [ -f "${target}" ]; then
30.   rm "${target}"
31.   fi
32.   mv ${target}-backup ${target}
33.   echo "Rollback Complete"
34.   fi
35.    
36.   # run
37.   echo "Starting..."
38.   ./run.sh ${target}
39.   echo "Done"

--------------------- 
作者：极客Geek 
来源：CSDN 
原文：https://blog.csdn.net/netdxy/article/details/79431415 
版权声明：本文为博主原创文章，转载请附上博文链接！

  文章知识点与官方知识档案匹配，可进一步学习相关知识 Go技能树首页概览1787 人正在系统学习中

标签：实战,ps,target,部署,pid,echo,Golang,sh,fi
From： https://www.cnblogs.com/python9090/p/16997842.html