• docker部署Golang程序


    在这里我们会介绍两种部署方式:

    1. 直接构建镜像
    2. 分阶段构建镜像

    方式一:直接构建镜像

        首先在我们的项目根目录下编写Dockerfile文件,文件名称就是Dockerfile,没有后缀名嗷!!
        具体请参考如下内容:

    FROM golang:alpine
    
    # 为我们的镜像设置必要的环境变量
    # GO111MODULE=on 开启go mod
    # CGO_ENABLED=1, 进⾏编译时, 会将⽂件中引⽤libc的库(⽐如常⽤的net包),以动态链接的⽅式⽣成⽬标⽂件。
    # CGO_ENABLED=0, 进⾏编译时, 则会把在⽬标⽂件中未定义的符号(外部函数)⼀起链接到可执⾏⽂件中。
    # GOOS 编译目标系统为Linux
    # GOARCH=amd64:编译目标的指令集架构为 64位 x86架构
    # GOPROXY=https://goproxy.cn 指定一下国内源,提升下载速度
    ENV GO111MODULE=on \
        CGO_ENABLED=0 \
        GOOS=linux \
        GOARCH=amd64 \
        GOPROXY=https://goproxy.cn
    
    # 移动到工作目录:/build
    WORKDIR /build
    
    # 复制项目中的 go.mod 和 go.sum文件并下载依赖信息
    COPY go.mod .
    COPY go.sum .
    RUN go mod download
    
    # 将代码复制到容器中
    COPY . .
    
    # 将我们的代码编译成二进制可执行文件app
    RUN go build -o app .
    
    # 移动到用于存放生成的二进制文件的 /dist 目录
    WORKDIR /dist
    
    # 将二进制文件从 /build 目录复制到这里
    RUN cp /build/app .
    
    # 声明服务端口,但是不起实际作用,只是一个标识,具体启动端口是容器中程序的配置
    EXPOSE 8888
    
    # 启动容器时运行的命令
    CMD ["/dist/app"]
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40

        Dockerfile中的内容中的字段不是固定的,根据自己实际情况去修改里边的文件路径、端口号、环境变量、可执行文件名称等
        编写完成后,在Dockerfile文件路径下执行命令,命令最后有一个点“.”,可不要忘记咯

    docker build -t test_app:v1.0 .

        接下来就是等了

    PS G:\Go_OBJ\src\test> docker build -t test_app:v1.0 .
     => [internal] load build definition from Dockerfile                                                                                                                                                                             0.0s 
     => => transferring dockerfile: 1.03kB                                                                                                                                                                                           0.0s 
     => [internal] load .dockerignore                                                                                                                                                                                                0.0s 
     => => transferring context: 2B                                                                                                                                                                                                  0.0s 
     => [internal] load metadata for docker.io/library/golang:alpine                                                                                                                                                                 5.9s 
     => [internal] load build context                                                                                                                                                                                                0.3s 
     => => transferring context: 39.05MB                                                                                                                                                                                             0.3s 
     => [1/6] FROM docker.io/library/golang:alpine@sha256:7cc62574fcf9c5fb87ad42a9789d5539a6a085971d58ee75dd2ee146cb8a8695                                                                                                           0.0s 
     => CACHED [2/6] WORKDIR /build                                                                                                                                                                                                  0.0s 
     => [3/6] COPY . .                                                                                                                                                                                                               0.4s 
     => CANCELED [4/6] RUN go build -o app .                                                                                                                                                                                        56.8s 
    context canceled
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

        在执行过程中可能会报time out的错,这个就是网络问题了,可能是被墙了,也可能是本地的网络不好,我们再重新执行一下命令试一下就可以!
       执行完成后,我们就查看一下镜像是否成功生成

    PS G:\Go_OBJ\src\bluebell> docker images
    REPOSITORY   TAG       IMAGE ID       CREATED          SIZE 
    test_app     v1.0      0f0c534e7c19   22 minutes ago   955MB
    test_app     v2.0      4195fcf1f956   49 minutes ago   39MB
    
    • 1
    • 2
    • 3
    • 4

        我们可以看到test_app:v1.0镜像已经成功生成,我们就可以使用docker run 的命令去启动了!

        通过上边的内容,我们成功构建了test_app:v1.0的镜像了,但是我们也可以明显的看出,这个镜像有955M,属实有点大啊,在我们实际应用中,其实只需要里边生成好的二进制可执行文件,其他的环境我们并不关心,也并不需要,这个时候我们可以用分阶段构建镜像,就是我们先去生成一个环境齐全的镜像,然后构生成我们的二进制可执行文件,然后我们把这个可执行文件赋值到另一个小镜像内,并且只保留这个小镜像。可能我讲的有点不清楚,接下来咱们直接上手!

    方式二:分阶段构建镜像

        第一步仍然是编写Dockerfile文件,参考内容如下:

    # 拉取 golang镜像,让其作为一个构造者
    FROM golang:alpine AS builder
    
    # 为我们的镜像设置必要的环境变量
    ENV GO111MODULE=on \
        CGO_ENABLED=0 \
        GOOS=linux \
        GOARCH=amd64 \
        GOPROXY=https://goproxy.cn
    
    # 移动到工作目录:/build
    WORKDIR /build
    
    # 复制项目中的 go.mod 和 go.sum文件并下载依赖信息
    COPY go.mod .
    COPY go.sum .
    RUN go mod download
    
    # 将代码复制到容器中
    COPY . .
    
    # 将我们的代码编译成二进制可执行文件 app
    RUN go build -o app .
    
    ###################
    # 接下来创建一个小镜像
    ###################
    FROM scratch
    
    # 程序中可能有配置文件,我们将配置文件也复制过来,拷贝到相应目录
    COPY ./cfg /cfg
    
    # 从builder镜像中把/dist/app 拷贝到当前目录
    COPY --from=builder /build/app /
    
    # 声明服务端口(不起实际作用,只是一个标识,具体启动端口是容器中程序的配置)
    EXPOSE 8081
    
    # 需要运行的命令
    ENTRYPOINT ["/app", "cfg/config.yaml"]
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40

        然后我们同样是要运行命令

    docker build -t test_app:v1.0 .

    PS G:\Go_OBJ\src\test> docker build -t test_app:v2.0 .
    [+] Building 35.6s (11/11) FINISHED
     => [internal] load build definition from Dockerfile                                                                                                                                                                             0.0s 
     => => transferring dockerfile: 1.12kB                                                                                                                                                                                           0.0s 
     => [internal] load .dockerignore                                                                                                                                                                                                0.0s 
     => => transferring context: 2B                                                                                                                                                                                                  0.0s 
     => [internal] load metadata for docker.io/library/golang:alpine                                                                                                                                                                 2.1s 
     => [1/6] FROM docker.io/library/golang:alpine@sha256:7cc62574fcf9c5fb87ad42a9789d5539a6a085971d58ee75dd2ee146cb8a8695                                                                                                           0.0s 
     => [builder 7/7] RUN go build -o bluebell_app .                                                                                                                                                                                 8.1s 
     => CACHED [stage-1 1/2] COPY ./conf /conf                                                                                                                                                                                       0.0s 
     => CACHED [stage-1 2/2] COPY --from=builder /build/bluebell_app /                                                                                                                                                               0.0s 
     => exporting to image                                                                                                                                                                                                           0.0s 
     => => exporting layers                                                                                                                                                                                                          0.0s 
     => => writing image sha256:4195fcf1f9567697d490365e21a79816093f44f4be6bf44521a83c2179421268                                                                                                                                     0.0s 
     => => naming to docker.io/library/test_app:v2.0                                                                                                                                                                                 0.0s 
    
    Use 'docker scan' to run Snyk tests against images to find vulnerabilities and learn how to fix them
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

        我们再查看一下镜像是否构建成功

    PS G:\Go_OBJ\src\bluebell> docker images
    REPOSITORY   TAG       IMAGE ID       CREATED          SIZE
    test_app     v1.0      0f0c534e7c19   22 minutes ago   955MB
    test_app     v2.0      4195fcf1f956   49 minutes ago   39MB
    
    • 1
    • 2
    • 3
    • 4

        这时我们可以看出镜像已经构建成功了,并且只有39M,也非常符合预期!

        此内容是参照七米老师的博客理解的,大家也可以去他的网站看一下:liwenzhou.com,感谢阅读!



    2022-06-30

  • 相关阅读:
    实战篇:单库单表变更成多库多表
    Android——解决BottomNavigationView+Fragment重建与重叠问题
    【译】为什么Kotlin Synthetics被废弃了?我们用什么来替代?
    动规算法-地下城游戏
    windows系统中用windbg收集程序崩溃信息
    虹科分享 | 如何利用网络万用表有效地解决网络中的性能问题
    JAVA知识点笔记
    搭建微信小程序环境及项目结构介绍
    实验(五):外部中断实验
    Fundamentals of Electrostatic Discharge-WHO DEVELOPS STANDARDS?
  • 原文地址:https://blog.csdn.net/weixin_43871135/article/details/125539610