得之我幸 失之我命

when someone abandons you，it is him that gets loss because he lost someone who truly loves him but you just lost one who doesn’t love you.

| jenkins

jf 环境变量的作用范围、获取、设置

Jenkins 环境变量是通过 env 变量公开的全局变量，可以在 Jenkins 文件中的任何位置使用

存储在 env 变量中的任何值都存储为字符串类型

环境变量可以在 pipeline 顶层、特定 stage 或 script 块内部设置

环境变量的作用范围

1、要注意的是单引号 ‘，双引号 "，三单引号 ‘’’，三双引号 “”" 的使用区别；三双引号 “”" 内，单引号和双引号均可以打印变量；三单引号 ‘’’ 内，单引号打印原始字符串，双引号可以打印变量

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
41
42
stages
{
    stage('Quote Test')
    {
        steps
        {
            echo BUILD_ID  // 92
            echo 'BUILD_ID'  // BUILD_ID
            echo "BUILD_ID"  // BUILD_ID
            echo $BUILD_ID  // 报错
            echo '$BUILD_ID'  // $BUILD_ID
            echo "$BUILD_ID"  // 92
            echo ${BUILD_ID}  // 报错
            echo '${BUILD_ID}'  // ${BUILD_ID}
            echo "${BUILD_ID}"  // 92
            script
            {
                echo BUILD_ID  // 92
                echo 'BUILD_ID'  // BUILD_ID
                echo "BUILD_ID"  // BUILD_ID
                echo $BUILD_ID  // 报错
                echo '$BUILD_ID'  // $BUILD_ID
                echo "$BUILD_ID"  // 92
                echo ${BUILD_ID}  // 报错
                echo '${BUILD_ID}'  // $BUILD_ID
                echo "${BUILD_ID}"  // 92
                sh """
                    # 在 sh 三双引号内，均可以打印变量
                    echo ${BUILD_ID}  # 92
                    echo '${BUILD_ID}'  # 92
                    echo "${BUILD_ID}"  # 92
                """
                sh '''
                    # 在 sh 三单引号内，使用单引号打印单引号内字符串
                    echo ${BUILD_ID}  # 92
                    echo '${BUILD_ID}'  # ${BUILD_ID}
                    echo "${BUILD_ID}"  # 92
                '''
            }
        }
    }
}

2、在 pipeline 中使用 environment{} 块以 VARIABLE_NAME = value 的形式定义的变量在每个 stage 内都有效；在一个 stage 中使用 environment{} 块以 VARIABLE_NAME = value 的形式定义的变量仅在该 stage 中有效

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
environment
{
    FOO0 = "023"
}
stages
{
    stage('Env Variables Scope Test1')
    {
        environment
        {
            FOO1 = "123"
        }
        steps
        {
            script
            {
                echo FOO0  // 023
                echo FOO1  // 123
                sh "printenv"  // FOO0/FOO1 均被打印
            }
        }
    }
    stage('Env Variables Scope Test2')
    {
        steps
        {
            script
            {
                echo FOO0  // 023
                echo FOO1  // 报错，hudson.remoting.ProxyException: groovy.lang.MissingPropertyException: No such property: FOO1 for class: WorkflowScript
                sh "printenv"  // 仅 FOO0 被打印
            }
        }
    }
}

3.1、在 script 中以 env.VARIABLE_NAME = value 的形式定义的变量在每个 stage 内有效

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
stages
{
    stage('Env Variables Scope Test1')
    {
        steps
        {
            script
            {
                env.FOO = "abc"
                echo "${FOO}"  // abc
            }
            echo "${FOO}"  // abc
        }
    }
    stage('Env Variables Scope Test2')
    {
        steps
        {
            script
            {
                echo "${FOO}"  // abc，在 script 内、sh 外、双引号内有效
                sh "printenv"  // FOO 被打印
                sh """
                    # 打印结果 abc，在 script 内、sh 内、三双引号内有效
                    echo "${FOO}"  # abc
                    printenv  // FOO 被打印
                """
                sh '''
                    # 打印结果 abc，在 script 内、sh 内、三单引号内有效
                    echo "${FOO}"  # abc
                    printenv  // FOO 被打印
                '''
            }
        }
    } 
}

3.2、⚠️ 在 script 中以 VARIABLE_NAME = value 的形式定义的变量不存储在 env 变量中；在每个 stage 内 sh 外以及 sh 三双引号内有效，sh 三单引号内无效；此形式定义的变量在 sharedlibraries 中不能直接使用

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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
stages
{
    stage('Env Variables Scope Test1')
    {
        steps
        {
            script
            {
                FOO = "abc"
                echo "${FOO}"  // abc
            }
            echo "${FOO}"  // abc
        }
    }
    stage('Env Variables Scope Test2')
    {
        steps
        {
            echo "${FOO}"  // abc
            sh "printenv"  // 不存在 FOO
            sh """
                # 打印结果 abc，在 script 外的 sh 三双引号内有效
                echo ${FOO}
                echo '${FOO}'
                echo "${FOO}"
                printenv
            """
            sh '''
                # 打印结果 abc，在 sh 三单引号内无效
                echo ${FOO}  # 空打印
                echo '${FOO}'  # ${FOO}
                echo "${FOO}"  # 空打印
                printenv  # 不存在 FOO
            '''
            script
            {
                echo "${FOO}"  // abc
                sh "printenv"  // 不存在 FOO
                sh """
                    # 打印结果 abc，在 script 内的 sh 三双引号内有效
                    echo ${FOO}
                    echo '${FOO}'
                    echo "${FOO}"
                    printenv  # 不存在 FOO
                """
                sh '''
                    # 打印结果 abc，在 sh 三单引号内无效
                    echo ${FOO}  # 空打印
                    echo '${FOO}'  # ${FOO}
                    echo "${FOO}"  # 空打印
                    printenv  # 不存在 FOO
                '''
            }
        }
    } 
}

环境变量的获取

1、通过访问 ${YOUR_JENKINS_HOST}/env-vars.html 页可以查看所有可用的内置环境变量

2、使用 printenv 打印查看所有环境变量

1
2
3
4
5
6
7
8
9
10
11
12
13
pipeline
{
    stages
    {
        stage("Env Variables")
        {
            steps
            {
                sh "printenv"
            }
        }
    }
}

3、通过 env 对象以管道步骤访问某个环境变量

例如 env.BUILD_NUMBER 访问当前的内部版本号，也可以省略 env，但在这种变体中，可能会引起困惑，不知道这个 BUILD_NUMBER 是来自于 env

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
pipeline
{
    stages
    {
        stage("Env Variables")
        {
            steps
            {
                echo "The build number is ${env.BUILD_NUMBER}"
                echo "You can also use \${BUILD_NUMBER} -> ${BUILD_NUMBER}"
                sh 'echo "I can access ${BUILD_NUMBER} in shell command as well."'
            }
        }
    }
}

环境变量的设置

1、使用 environment{} 块

⚠️ 注意事项：

  • 只能在 pipeline 或者 stage 中
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
pipeline
{
    environment
    {
        FOO1 = "bar1"  // env.FOO1 assigned bar1
        BUILD_NUMBER = "2"  // override the default BUILD_NUMBER, assigned 2
    }

    stages
    {
        stage("Env Variables")
        {
            environment
            {
                FOO2 = "bar2"  // env.FOO2 assigned bar2
                FOO1 = "bar3"  // override pipeline level FOO1 env variable, assigned bar3
            }
        }
    }
}

2、使用 env.VARIABLE_NAME

⚠️ 注意事项：

  • 无法使用命令 env.VAR=“value” 赋值重写使用 environment{}块设置的变量
  • 命令式 env.VAR=“value” 赋值只能覆盖使用命令式赋值创建的环境变量
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
pipeline
{
    stages
    {
        stage("Env Variables Create")
        {
            steps
            {
                script
                {
                    env.FOO = "bar"  // env.FOO assigned bar
                }
            }
        }

        stage("Env Variables Notice Test")
        {
            environment
            {
                FOO1 = "bar1"  // env.FOO1 assigned bar1
            }
            steps
            {
                script
                {
                    env.FOO1 = "bar"  // ❌ it can't override env.FOO declared at the stage (or pipeline) level
                    env.FOO = "bar1"  // override env.FOO, assigned bar1
                }
            }
        }
    }
}

3、使用 withEnv([“VARIABLE_NAME=value”]){} 块以声明方式设置环境变量

⚠️ 注意事项：

  • value 可以使用变量
  • 可以覆盖任何环境变量但是，只在紧接着的大括号内有效，在大括号外无效
  • withEnv 不能放在 sh 里，因为它不是一个 shell 命令
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
pipeline
{
    stages
    {
        stage("Env Variables Create")
        {
            steps
            {
                withEnv(["FOO=bar"])
                {
                    echo "FOO = ${env.FOO}"  // env.FOO assigned bar
                }
            }
        }

        stage("Env Variables Notice Test")
        {
            environment
            {
                FOO1 = "bar1"  // env.FOO1 assigned bar1
            }
            steps
            {
                script
                {
                    env.FOO2 = "bar2"  // env.FOO2 assigned bar2
                }
                withEnv(["FOO1=foobar1"]){}  // it can override any env variable, env.FOO1 assigned foobar1
                withEnv(["FOO2=foobar2"]){}  // it can override any env variable, env.FOO2 assigned foobar2
                withEnv(["BUILD_NUMBER=1"]){}  // it can override any env variable, env.BUILD_NUMBER assigned 1
            }
        }
    }
}

be slow to promise and quick to perform.

ESC