docker 中运行的 jenkins 使用 npm 构建 Node.js 应用

一、jenkins 的安装

配置要求

• 最小 256MB 内存，推荐 512MB 以上
• 10GB硬盘空间，用于安装 Jenkins、Docker 镜像和容器

在 Docker 中运行 Jenkins

我们在服务器上面为 jenkins 准备数据目录，假设为/home/data/www/jenkins.wzlinux.com，前提是我们已经在服务器上面安装好了 docker。

docker run \
  --name jenkins \
  -u root \
  -d \
  -p 8080:8080 \
  -p 50000:50000 \
  -e TZ="Asia/Shanghai" \
  -v /home/data/www/jenkins.wzlinux.com:/var/jenkins_home \
  -v /var/run/docker.sock:/var/run/docker.sock \
  --restart=on-failure:10 \
  jenkinsci/blueocean

配置 jenkins

使用浏览器打开服务器的 8080 端口，并等待 Unlock Jenkins 页面出现。

可以使用如下命令获取管理员的密码：

docker logs jenkins

关于插件的安装我这里也不介绍了，有什么不懂的可以微信联系我。

二、配置 pipeline

2.1、配置源

我们从 github 上面找一个 nodejs 的案例作为我们的代码源，当然你也可以选择自己的 gitlab。

https://github.com/jenkins-docs/simple-node-js-react-npm-app

2.2、创建我们的 pipeline

1. 进入首页，点击 New Item
2. 在项目名的地方，我们填写simple-node-js-react-npm-ap
3. 类型我们选择 pipeline

2.3、拉取源代码

点击确定之后，我们进入到 project 的配置界面，我们找到 pipeline 这一部分。

我们可以把 pipeline 写入到 jenkinsfile，然后保存到代码根目录，也可以直接在这里填写，我们选择在这里填写。

pipeline {
    agent {
        docker {
            image 'node:10.20.1-alpine3.11' 
            args '-v $HOME/.m2:/root/.m2'
        }
    }
    stages {
        stage('checkout') {
            steps {
                git 'https://github.com/jenkins-docs/simple-node-js-react-npm-app'
            }
        }
    }
}

• 因为我们是构建 nodejs 项目，所以我们这里选择 node 的镜像，大家可以选择自己的版本，使用 docker 的好处就是，一些工具我们也不需要再去安装，然后到系统工具配置了，直接选择自己需要的工具的 docker 镜像就可以了。
• 我们这里去拉取 github 的代码，如果语法不会的话，输入框下面有流水线语法器，可以随时去生成，也可以使用我们的 gitlab。

我们运行一下，看下输出结果如何。

并且查看一下 workspace，看下载下来的代码

2.4、node.js 构建

那我们再完善一下 pipeline，我们增加打包构建，我这里选择的 node 版本比较低，大家可以去 docker hub 上面去选择更新的版本。

pipeline {
    agent {
        docker {
            image 'node:10.20.1-alpine3.11'
            args '-v $HOME/.m2:/root/.m2'
        }
    }
    stages {
        stage('checkout') {
            steps {
                git 'https://github.com/jenkins-docs/simple-node-js-react-npm-app'
            }
        }
        stage('build') {
            steps {
                sh 'npm install'
                sh 'npm run build'
            }
        }        
    }
}

然后提交，查看一下运行结果如何：

然后再查看一下 wordspace 里面构建的文件，构建的文件在 build 目录下面。我对代码也不是太清楚，有的好像生成在 dist 目录。

2.5、发布到服务器上面

这里我们还是选择插件 Publish over SSH，配置这个插件，我简要说一下。

这里的 Remote Directory 比较重要，后面所有的文件都会传到以这个目录为根目录的目录下面。

这里配置好了，但是我们要写 pipeline，这里我们只能借住流水线语法生成器，我们这里计划把 build 里面的代码放到目标服务器的 /tmp/node 目录下面。

Source files：需要上传的文件（注意：相对于工作区的路径。看后面的配置可以填写多个，默认用,分隔），为了简要也可以写build/*。
Remove prefix：移除前缀（只能指定Source files中的目录）。
Remote directory：远程目录（这里也是相对目录，目录根据我们配 ss h的时候填写的Remote Directory 路径，我写的是/root，所以文件会被上传到我们的 /root/nodejs 目录下面。

最终的 pipeline 如下：

pipeline {
    agent {
        docker {
            image 'node:10.20.1-alpine3.11'
            args '-v $HOME/.m2:/root/.m2'
        }
    }
    stages {
        stage('checkout') {
            steps {
                git 'https://github.com/jenkins-docs/simple-node-js-react-npm-app'
            }
        }
        stage('build') {
            steps {
                sh 'npm install'
                sh 'npm run build'
            }
        }
        stage('Deliver') {
            steps {
                sshPublisher(publishers: [sshPublisherDesc(configName: '应用服务器4', transfers: [sshTransfer(cleanRemote: false, excludes: '', execCommand: '''ls nodejs;
cp -r nodejs/* /tmp/node;
ls /tmp/node''', execTimeout: 120000, flatten: false, makeEmptyDirs: false, noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: 'nodejs', remoteDirectorySDF: false, removePrefix: 'build', sourceFiles: 'build/*')], usePromotionTimestamp: false, useWorkspaceInPromotion: false, verbose: false)])
            }
        }
    }
}

运行，我们查看一下结果是否如我们预期。

我们发现了一点问题，发现只能传送文件，不能传送文件夹，有可能就是不支持文件，也有可能我还没有完全搞明白，欢迎大家留意告诉我。

其实解决办法也有很多，我们在第二步构建完成之后，可以使用 zip 命令对这个文件夹打包，然后我们再使用第三步去获取，我这里不进行演示了，大家请自行测试。

三、最佳实践

Customizing the execution environment

Pipeline is designed to easily use Docker images as the execution environment for a single Stage or the entire Pipeline. Meaning that a user can define the tools required for their Pipeline, without having to manually configure agents. Practically any tool which can be packaged in a Docker container. can be used with ease by making only minor edits to a Jenkinsfile.

pipeline {
    agent {
        docker { image 'node:7-alpine' }
    }
    stages {
        stage('Test') {
            steps {
                sh 'node --version'
            }
        }
    }
}

Caching data for containers

Many build tools will download external dependencies and cache them locally for future re-use. Since containers are initially created with "clean" file systems, this can result in slower Pipelines, as they may not take advantage of on-disk caches between subsequent Pipeline runs.

Pipeline supports adding custom arguments which are passed to Docker, allowing users to specify custom Docker Volumes to mount, which can be used for caching data on the agent between Pipeline runs. The following example will cache ~/.m2 between Pipeline runs utilizing the maven container, thereby avoiding the need to re-download dependencies for subsequent runs of the Pipeline.

pipeline {
    agent {
        docker {
            image 'maven:3-alpine'
            args '-v $HOME/.m2:/root/.m2'
        }
    }
    stages {
        stage('Build') {
            steps {
                sh 'mvn -B'
            }
        }
    }
}

Using multiple containers

It has become increasingly common for code bases to rely on multiple, different, technologies. For example, a repository might have both a Java-based back-end API implementation and a JavaScript-based front-end implementation. Combining Docker and Pipeline allows a Jenkinsfile to use multiple types of technologies by combining the agent {} directive, with different stages.

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'
            }
        }
    }
}

Using a Dockerfile

For projects which require a more customized execution environment, Pipeline also supports building and running a container from a Dockerfile in the source repository. In contrast to the previous approach of using an "off-the-shelf" container, using the agent { dockerfile true } syntax will build a new image from a Dockerfile rather than pulling one from Docker Hub.

Re-using an example from above, with a more custom Dockerfile:

Dockerfile

FROM node:7-alpine

RUN apk add -U subversion

By committing this to the root of the source repository, the Jenkinsfile can be changed to build a container based on this Dockerfile and then run the defined steps using that container:

Jenkinsfile (Declarative Pipeline)

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

The agent { dockerfile true } syntax supports a number of other options which are described in more detail in the Pipeline Syntax section.

Advanced Usage with Scripted Pipeline

Running "sidecar" containers

Using Docker in Pipeline can be an effective way to run a service on which the build, or a set of tests, may rely. Similar to the sidecar pattern, Docker Pipeline can run one container "in the background", while performing work in another. Utilizing this sidecar approach, a Pipeline can have a "clean" container provisioned for each Pipeline run.

Consider a hypothetical integration test suite which relies on a local MySQL database to be running. Using the withRun method, implemented in the Docker Pipeline plugin’s support for Scripted Pipeline, a Jenkinsfile can run MySQL as a sidecar:

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.
     */
    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'
    }
}

This example can be taken further, utilizing two containers simultaneously. One "sidecar" running MySQL, and another providing the execution environment, by using the Docker container links.

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") {
            /* Wait until mysql service is up */
            sh 'while ! mysqladmin ping -hdb --silent; do sleep 1; done'
        }
        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'
        }
    }
}

The above example uses the object exposed by withRun, which has the running container’s ID available via the id property. Using the container’s ID, the Pipeline can create a link by passing custom Docker arguments to the inside() method.

The id property can also be useful for inspecting logs from a running Docker container before the Pipeline exits:

sh "docker logs ${c.id}"

Building containers

In order to create a Docker image, the Docker Pipeline plugin also provides a build() method for creating a new image, from a Dockerfile in the repository, during a Pipeline run.

One major benefit of using the syntax docker.build("my-image-name") is that a Scripted Pipeline can use the return value for subsequent Docker Pipeline calls, for example:

node {
    checkout scm

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

    customImage.inside {
        sh 'make test'
    }
}

The return value can also be used to publish the Docker image to Docker Hub, or a custom Registry, via the push() method, for example:

node {
    checkout scm
    def customImage = docker.build("my-image:${env.BUILD_ID}")
    customImage.push()
}

One common usage of image "tags" is to specify a latest tag for the most recently, validated, version of a Docker image. The push() method accepts an optional tag parameter, allowing the Pipeline to push the customImage with different tags, for example:

node {
    checkout scm
    def customImage = docker.build("my-image:${env.BUILD_ID}")
    customImage.push()

    customImage.push('latest')
}

The build() method builds the Dockerfile in the current directory by default. This can be overridden by providing a directory path containing a Dockerfile as the second argument of the build() method, for example:

node {
    checkout scm
    def testImage = docker.build("test-image", "./dockerfiles/test") 

    testImage.inside {
        sh 'make test'
    }
}

Builds test-image from the Dockerfile found at ./dockerfiles/test/Dockerfile.

It is possible to pass other arguments to docker build by adding them to the second argument of the build() method. When passing arguments this way, the last value in the that string must be the path to the docker file and should end with the folder to use as the build context)

This example overrides the default Dockerfile by passing the -f flag:

node {
    checkout scm
    def dockerfile = 'Dockerfile.test'
    def customImage = docker.build("my-image:${env.BUILD_ID}", "-f ${dockerfile} ./dockerfiles") 
}

Builds my-image:${env.BUILD_ID} from the Dockerfile found at ./dockerfiles/Dockerfile.test.

Using a remote Docker server

By default, the Docker Pipeline plugin will communicate with a local Docker daemon, typically accessed through /var/run/docker.sock.

To select a non-default Docker server, such as with Docker Swarm, the withServer() method should be used.

By passing a URI, and optionally the Credentials ID of a Docker Server Certificate Authentication pre-configured in Jenkins, to the method with:

node {
    checkout scm

    docker.withServer('tcp://swarm.example.com:2376', 'swarm-certs') {
        docker.image('mysql:5').withRun('-p 3306:3306') {
            /* do things */
        }
    }
}

Using a custom registry

By default the Docker Pipeline integrates assumes the default Docker Registry of Docker Hub.

In order to use a custom Docker Registry, users of Scripted Pipeline can wrap steps with the withRegistry() method, passing in the custom Registry URL, for example:

node {
    checkout scm

    docker.withRegistry('https://registry.example.com') {

        docker.image('my-custom-image').inside {
            sh 'make test'
        }
    }
}

For a Docker Registry which requires authentication, add a "Username/Password" Credentials item from the Jenkins home page and use the Credentials ID as a second argument to withRegistry():

node {
    checkout scm

    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/doc/book/pipeline/docker/

欢迎大家扫码关注，获取更多信息