pipeline中使用docker

先在jenkins中安装docker pipeline插件，并将jenkins加入docker用户组。

usermod -aG docker jenkins

在镜像中执行命令：

pipeline {
    agent {
        docker { image 'node:7-alpine' } //定义镜像
    }
    stages {
        stage('Test') {
            steps {
                sh 'node --version' // 在镜像 node:7-alpine 中执行该命令
            }
        }
    }
}

为容器添加运行参数：

pipeline {
    agent {
        docker {
            image 'maven:3-alpine'
            args '-v $HOME/.m2:/root/.m2' // 为容器添加运行参数
        }
    }
    stages {
        stage('Build') {
            steps {
                sh 'mvn -B' // 在容器中执行该命令
            }
        }
    }
}

在多个容器中执行命令：

pipeline {
    agent none
    stages {
        stage('Back-end') {
            agent {
                docker { image 'maven:3-alpine' } // 定义镜像一
            }
            steps {
                sh 'mvn --version' // 在容器一中执行命令
            }
        }
        stage('Front-end') {
            agent {
                docker { image 'node:7-alpine' } // 定义镜像二
            }
            steps {
                sh 'node --version' // 在容器二中执行命令
            }
        }
    }
}

在自己构建的镜像中执行命令：

pipeline {
    agent { dockerfile true }
    stages {
        stage('Test') {
            steps {
                sh 'node --version'
                sh 'svn --version'
            }
        }
    }
}

运行一个sidecar容器：withRun是运行参数。

node {
    checkout scm
    /*
     * In order to communicate with the MySQL server, this Pipeline explicitly
     * maps the port (`3306`) to a known port on the host machine.
     * 将这个镜像的3306端口映射到主机了，这样就可以为jenkins提供测试环境了，而无需在本地安装mysql了
     */
    docker.image('mysql:5').withRun('-e "MYSQL_ROOT_PASSWORD=my-secret-pw" -p 3306:3306') { c ->
        /* Wait until mysql service is up */
        sh 'while ! mysqladmin ping -h0.0.0.0 --silent; do sleep 1; done'
        /* Run some tests which require MySQL */
        sh 'make check'
    }
}

运行一组容器：

node {
    checkout scm
    // 最外面跑的容器是提供本次构建的测试环境的
    docker.image('mysql:5').withRun('-e "MYSQL_ROOT_PASSWORD=my-secret-pw"') { c ->
        // 这个容器是在内部执行了一个命令
        docker.image('mysql:5').inside("--link ${c.id}:db") { // inside表示在容器内部运行命令
            /* Wait until mysql service is up */
            sh 'while ! mysqladmin ping -hdb --silent; do sleep 1; done'
        }
        // 这个容器在内部执行了一个需要mysql服务的命令
        docker.image('centos:7').inside("--link ${c.id}:db") {
            /*
             * Run some tests which require MySQL, and assume that it is
             * available on the host name `db`
             */
            sh 'make check'
        }
    }
}

可以查看日志：

sh "docker logs ${c.id}"

构建镜像：

node {
    checkout scm

    def customImage = docker.build("my-image:${env.BUILD_ID}") // imagename:tag

    customImage.inside {
        sh 'make test' // 在构建好的镜像内部执行测试命令
    }
}

将构件好的镜像上传到仓库：

node {
    checkout scm
    def customImage = docker.build("my-image:${env.BUILD_ID}")
    customImage.push()
    // customImage.push('latest') 也可以指定上传不同的标签
}

指定构建镜像的Dockerfile：

node {
    checkout scm
    def testImage = docker.build("test-image", "./dockerfiles/test") // 第二个参数可以指定构件进行的Dockerfile

    testImage.inside {
        sh 'make test'
    }
}

添加其他的构建参数：

node {
    checkout scm
    def dockerfile = 'Dockerfile.test'
    // 第二个参数还可以添加其他构建镜像的参数，参数最后的位置是Dockerfile文件的位置
    def customImage = docker.build("my-image:${env.BUILD_ID}", "-f ${dockerfile} ./dockerfiles")
}

调用远程的docker：

node {
    checkout scm

    // 调用远程的docker服务来跑容器
    docker.withServer('tcp://swarm.example.com:2376', 'swarm-certs') {// 第二个参数是docker容器所需的认证
        // 跑这个镜像来提供本次测试的运行环境
        docker.image('mysql:5').withRun('-p 3306:3306') {
            /* do things */
        }
    }
}

使用自定义的docker仓库：

node {
    checkout scm
    // 自定义的docker仓库
    docker.withRegistry('https://registry.example.com') {
        // 提供运行环境并执行命令
        docker.image('my-custom-image').inside {
            sh 'make test'
        }
    }
}

自定义仓库的密码和账号：

node {
    checkout scm
    // 设置自定义仓库的认证，第二个参数是在jenkins中设置好的认证id，填上去就可以了
    docker.withRegistry('https://registry.example.com', 'credentials-id') {
        // 构建镜像
        def customImage = docker.build("my-image:${env.BUILD_ID}")
        // 上传镜像
        /* Push the container to the custom Registry */
        customImage.push()
    }
}

官方文档地址：

https://www.jenkins.io/zh/doc/book/pipeline/docker/
https://www.jenkins.io/zh/doc/book/pipeline/syntax/