Jenkins Golang 声明式管道：构建 Docker 映像并推送到 Docker Hub

Golang小白一枚，正在不断学习积累知识，现将学习到的知识记录一下，也是将我的所得分享给大家！而今天这篇文章《Jenkins Golang 声明式管道：构建 Docker 映像并推送到 Docker Hub》带大家来了解一下##content_title##，希望对大家的知识积累有所帮助，从而弥补自己的不足，助力实战开发！

我正在尝试为我的 golang 项目创建一个 docker 镜像，并通过 jenkins declarative pipeline 将其上传到 docker hub。

我能够构建我的项目并运行所有测试。

我的jenkinsfile如下：

#!/usr/bin/env groovy
// the above line is used to trigger correct syntax highlighting.

pipeline {
    agent { docker { image 'golang' } }

    stages {
        stage('build') {   
            steps {                                           
                // create our project directory.
                sh 'cd ${gopath}/src'
                sh 'mkdir -p ${gopath}/src/my_project_directory'

                // copy all files in our jenkins workspace to our project directory.                
                sh 'cp -r ${workspace}/* ${gopath}/src/my_project_directory'

                // copy all files in our "vendor" folder to our "src" folder.
                sh 'cp -r ${workspace}/vendor/* ${gopath}/src'

                // build the app.
                sh 'go build'
            }            
        }

        // each "sh" line (shell command) is a step,
        // so if anything fails, the pipeline stops.
        stage('test') {
            steps {                                
                // remove cached test results.
                sh 'go clean -cache'

                // run unit tests.
                sh 'go test ./... -v'                                  
            }
        }           
    }
}

我的dockerfile（如果需要）如下：

# make a golang container from the "golang alpine" docker image from docker hub.
from golang:1.11.2-alpine3.8

# expose our desired port.
expose 9000

# create the proper directory.
run mkdir -p $gopath/src/my_project_directory

# copy app to the proper directory for building.
add . $gopath/src/my_project_directory

# set the work directory.
workdir $gopath/src/my_project_directory

# run cmd commands.
run go get -d -v ./...
run go install -v ./...

# provide defaults when running the container.
# these will be executed after the entrypoint.
# for example, if you ran docker run ,
# then the commands and parameters specified by cmd would be executed.
cmd ["my_project"]

我可以通过以下方式获取我的 docker hub 凭据：

environment {
    // extract the username and password of our credentials into "docker_credentials_usr" and "docker_credentials_psw".
    // (note 1: docker_credentials will be set to "your_username:your_password".)
    // the new variables will always be your_variable_name + _usr and _psw.
    docker_credentials = credentials('my_jenkins_credential_id')
}

作为参考，以下是我在 freestyle 工作中所做的工作：

Execute Shell:

    # Log in to Docker.
    sudo docker login -u $DOCKER_USERNAME -p $DOCKER_PASSWORD

    # Make a Docker image for our app.
    cd /var/lib/jenkins/tools/org.jenkinsci.plugins.golang.GolangInstallation/Go/src/MY_PROJECT_DIRECTORY/
    sudo docker build -t MY-PROJECT-img .

    # Tag our Docker image.
    sudo docker tag  MY-PROJECT-img   $DOCKER_USERNAME/MY-PROJECT-img

    # Push our Docker image to Docker Hub.
    sudo docker push $DOCKER_USERNAME/MY-PROJECT-img

    # Log out of Docker.
    docker logout

注意：我通过执行以下操作授予了 jenkins sudo 权限：

1. 打开 sudoers 文件进行编辑：

   sudo visudo -f /etc/sudoers

2. 按“i”进入 insert 模式。

3. 粘贴以下内容：

   詹金斯 all=(all) nopasswd: all

4. 按“esc”退出插入模式。

5. 要保存，请输入：

   ：w

6. 要退出，请输入：

   :q

我相信通过在我的声明式管道中添加新的 stage 和 agent 应该可以实现这一点，但我在网上没有找到任何内容。

解决方案

我明白了。

我更新的jenkinsfile如下：

#!/usr/bin/env groovy
// The above line is used to trigger correct syntax highlighting.

pipeline {
    // Lets Jenkins use Docker for us later.
    agent any    

    // If anything fails, the whole Pipeline stops.
    stages {
        stage('Build & Test') {   
            // Use golang.
            agent { docker { image 'golang' } }

            steps {                                           
                // Create our project directory.
                sh 'cd ${GOPATH}/src'
                sh 'mkdir -p ${GOPATH}/src/MY_PROJECT_DIRECTORY'

                // Copy all files in our Jenkins workspace to our project directory.                
                sh 'cp -r ${WORKSPACE}/* ${GOPATH}/src/MY_PROJECT_DIRECTORY'

                // Copy all files in our "vendor" folder to our "src" folder.
                sh 'cp -r ${WORKSPACE}/vendor/* ${GOPATH}/src'

                // Build the app.
                sh 'go build'               
            }            
        }

        stage('Test') {
            // Use golang.
            agent { docker { image 'golang' } }

            steps {                 
                // Create our project directory.
                sh 'cd ${GOPATH}/src'
                sh 'mkdir -p ${GOPATH}/src/MY_PROJECT_DIRECTORY'

                // Copy all files in our Jenkins workspace to our project directory.                
                sh 'cp -r ${WORKSPACE}/* ${GOPATH}/src/MY_PROJECT_DIRECTORY'

                // Copy all files in our "vendor" folder to our "src" folder.
                sh 'cp -r ${WORKSPACE}/vendor/* ${GOPATH}/src'

                // Remove cached test results.
                sh 'go clean -cache'

                // Run Unit Tests.
                sh 'go test ./... -v -short'            
            }
        }      

        stage('Docker') {         
            environment {
                // Extract the username and password of our credentials into "DOCKER_CREDENTIALS_USR" and "DOCKER_CREDENTIALS_PSW".
                // (NOTE 1: DOCKER_CREDENTIALS will be set to "your_username:your_password".)
                // The new variables will always be YOUR_VARIABLE_NAME + _USR and _PSW.
                // (NOTE 2: You can't print credentials in the pipeline for security reasons.)
                DOCKER_CREDENTIALS = credentials('my-docker-credentials-id')
            }

            steps {                           
                // Use a scripted pipeline.
                script {
                    node {
                        def app

                        stage('Clone repository') {
                            checkout scm
                        }

                        stage('Build image') {                            
                            app = docker.build("${env.DOCKER_CREDENTIALS_USR}/my-project-img")
                        }

                        stage('Push image') {  
                            // Use the Credential ID of the Docker Hub Credentials we added to Jenkins.
                            docker.withRegistry('https://registry.hub.docker.com', 'my-docker-credentials-id') {                                
                                // Push image and tag it with our build number for versioning purposes.
                                app.push("${env.BUILD_NUMBER}")                      

                                // Push the same image and tag it as the latest version (appears at the top of our version list).
                                app.push("latest")
                            }
                        }              
                    }                 
                }
            }
        }
    }

    post {
        always {
            // Clean up our workspace.
            deleteDir()
        }
    }
}

终于介绍完啦！小伙伴们，这篇关于《Jenkins Golang 声明式管道：构建 Docker 映像并推送到 Docker Hub》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布Golang相关知识，快来关注吧！